Initial commit

.gitignore

···
+testnet
+didplcbft-data
+didplcbft

abciapp/app.go

···
+package abciapp
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"sync"
+	"time"
+
+	abcitypes "github.com/cometbft/cometbft/abci/types"
+	"github.com/cosmos/iavl"
+	"github.com/dgraph-io/badger/v4"
+	"github.com/palantir/stacktrace"
+	"github.com/samber/lo"
+	"tangled.org/gbl08ma/didplcbft/badgeradapter"
+	"tangled.org/gbl08ma/didplcbft/plc"
+	"tangled.org/gbl08ma/didplcbft/store"
+)
+
+type DIDPLCApplication struct {
+	plc            plc.PLC
+	tree           *iavl.MutableTree
+	fullyClearTree func() error
+
+	snapshotDirectory string
+	snapshotApplier   *snapshotApplier
+
+	lastProcessedProposalHash          []byte
+	lastProcessedProposalExecTxResults []*abcitypes.ExecTxResult
+}
+
+// store and plc must be able to share transaction objects
+func NewDIDPLCApplication(badgerDB *badger.DB, snapshotDirectory string) (*DIDPLCApplication, plc.PLC, func(), error) {
+	treePrefix := []byte{}
+	mkTree := func() *iavl.MutableTree {
+		return iavl.NewMutableTree(badgeradapter.AdaptBadger(badgerDB, treePrefix), 2048, false, iavl.NewNopLogger())
+	}
+
+	tree := mkTree()
+
+	_, err := tree.Load()
+	if err != nil {
+		return nil, nil, func() {}, stacktrace.Propagate(err, "error loading latest version of the tree from storage")
+	}
+
+	err = os.MkdirAll(snapshotDirectory, os.FileMode(0755))
+	if err != nil {
+		return nil, nil, func() {}, stacktrace.Propagate(err, "")
+	}
+
+	d := &DIDPLCApplication{
+		tree:              tree,
+		snapshotDirectory: snapshotDirectory,
+	}
+	d.fullyClearTree = func() error {
+		// we assume this is called in a single-threaded context, which should be a safe assumption since we'll only call this during snapshot import
+		// and CometBFT only calls one ABCI method at a time
+		err := d.tree.Close()
+		if err != nil {
+			return stacktrace.Propagate(err, "")
+		}
+
+		if len(treePrefix) == 0 {
+			// this is probably slightly more efficient when we don't actually need to clear a prefix
+			err = badgerDB.DropAll()
+			if err != nil {
+				return stacktrace.Propagate(err, "")
+			}
+		} else {
+			err = badgerDB.DropPrefix(treePrefix)
+			if err != nil {
+				return stacktrace.Propagate(err, "")
+			}
+		}
+
+		*d.tree = *mkTree()
+		return nil
+	}
+
+	d.plc = plc.NewPLC(d)
+
+	fmt.Println("TREE SIZE", tree.Size())
+
+	var wg sync.WaitGroup
+	closeCh := make(chan struct{})
+	wg.Go(func() {
+		lastSnapshotVersion := int64(0)
+		for {
+			select {
+			case <-closeCh:
+				return
+			case <-time.After(1 * time.Minute):
+			}
+			treeVersion := tree.Version()
+			if lastSnapshotVersion == 0 || treeVersion > int64(lastSnapshotVersion+1000) {
+				err = d.createSnapshot(treeVersion, filepath.Join(snapshotDirectory, "snapshot.tmp"))
+				if err != nil {
+					fmt.Println("FAILED TO TAKE SNAPSHOT", stacktrace.Propagate(err, ""))
+				}
+				fmt.Println("TOOK SNAPSHOT OF VERSION", treeVersion)
+				lastSnapshotVersion = treeVersion
+			}
+		}
+
+	})
+
+	/*err = d.createSnapshot(tree.Version(), filepath.Join(snapshotDirectory, "snapshot.tmp"))
+	if err != nil {
+		return nil, nil, func() {}, stacktrace.Propagate(err, "")
+	}*/
+
+	/*
+		tree2 := iavl.NewMutableTree(dbm.NewMemDB(), 2048, false, iavl.NewNopLogger())
+		importer, err := tree2.Import(tree.Version())
+		if err != nil {
+			return nil, nil, func() {}, stacktrace.Propagate(err, "")
+		}
+		cimporter := iavl.NewCompressImporter(importer)
+
+		st = time.Now()
+		for _, node := range nodes {
+			err := cimporter.Add(&node)
+			if err != nil {
+				return nil, nil, func() {}, stacktrace.Propagate(err, "")
+			}
+		}
+		err = importer.Commit()
+		if err != nil {
+			return nil, nil, func() {}, stacktrace.Propagate(err, "")
+		}
+
+		fmt.Println("Took", time.Since(st), "to import", len(nodes), "nodes")
+		fmt.Println("Imported tree hash", hex.EncodeToString(tree2.Hash()), "and version", tree2.Version())
+	*/
+
+	return d, d.plc, func() {
+		closeCh <- struct{}{}
+		wg.Wait()
+		lo.Must0(tree.Close())
+	}, nil
+}
+
+var _ abcitypes.Application = (*DIDPLCApplication)(nil)
+var _ plc.TreeProvider = (*DIDPLCApplication)(nil)
+
+// ImmutableTree implements [plc.TreeProvider].
+func (d *DIDPLCApplication) ImmutableTree(version plc.TreeVersion) (store.PossiblyMutableTree, error) {
+	if version.IsMutable() {
+		return store.AdaptMutableTree(d.tree), nil
+	}
+	var v int64
+	if version.IsCommitted() {
+		var err error
+		v, err = d.tree.GetLatestVersion()
+		if err != nil {
+			return nil, stacktrace.Propagate(err, "")
+		}
+	} else {
+		var ok bool
+		v, ok = version.SpecificVersion()
+		if !ok {
+			return nil, stacktrace.NewError("unsupported TreeVersion")
+		}
+	}
+
+	it, err := d.tree.GetImmutable(v)
+	return store.AdaptImmutableTree(it), stacktrace.Propagate(err, "")
+}
+
+// MutableTree implements [plc.TreeProvider].
+func (d *DIDPLCApplication) MutableTree() (*iavl.MutableTree, error) {
+	return d.tree, nil
+}

abciapp/app_test.go

···
+package abciapp_test
+
+import (
+	"encoding/json"
+	"testing"
+
+	"github.com/cometbft/cometbft/abci/types"
+	"github.com/dgraph-io/badger/v4"
+	cbornode "github.com/ipfs/go-ipld-cbor"
+	"github.com/stretchr/testify/require"
+	"tangled.org/gbl08ma/didplcbft/abciapp"
+)
+
+func txJSONToCBOR(t *testing.T, jsonBytes []byte) []byte {
+	var v any
+	err := json.Unmarshal(jsonBytes, &v)
+	require.NoError(t, err)
+	out, err := cbornode.DumpObject(v)
+	require.NoError(t, err)
+	return out
+}
+
+func TestCheckTx(t *testing.T) {
+	badgerDB, err := badger.Open(badger.DefaultOptions("").WithInMemory(true))
+	require.NoError(t, err)
+	t.Cleanup(func() {
+		err := badgerDB.Close()
+		require.NoError(t, err)
+	})
+
+	app, _, cleanup, err := abciapp.NewDIDPLCApplication(badgerDB, "")
+	require.NoError(t, err)
+	t.Cleanup(cleanup)
+
+	// force one tree version to exist
+	_, err = app.Commit(t.Context(), &types.RequestCommit{})
+	require.NoError(t, err)
+
+	txJSONBytes := []byte(`
+		{
+			"action": "CreatePlcOp",
+			"arguments": {
+				"did": "did:plc:uyauirpjzk6le4ygqzatcwnq",
+				"operation": {
+					"sig": "JICl9boFJK12rmBbnuKLHdV51f_CMsrsmWUrgu17DDwtsqSiSazidWA_RZbJplYNr34bTwXyY7kkJ7oJHsbOjQ",
+					"prev": null,
+					"type": "plc_operation",
+					"services": {
+						"atproto_pds": {
+						"type": "AtprotoPersonalDataServer",
+						"endpoint": "https://at.tny.im"
+						}
+					},
+					"alsoKnownAs": [
+						"at://pdslabeler.at.tny.im"
+					],
+					"rotationKeys": [
+						"did:key:zQ3shhguVfzmkfgXHzrnSeDxzbAvw7NjiVUcu2nmkeiQUrZUM"
+					],
+					"verificationMethods": {
+						"atproto": "did:key:zQ3shsHRci5EP9nr7dzsy5QkzTbmm8uJBXbXdghbLc8JAqogb"
+					}
+				}
+			}
+		}`)
+
+	response, err := app.CheckTx(t.Context(), &types.RequestCheckTx{
+		Tx: txJSONToCBOR(t, txJSONBytes),
+	})
+	require.NoError(t, err)
+	require.Equal(t, uint32(0), response.Code)
+}

abciapp/execution.go

···
+package abciapp
+
+import (
+	"bytes"
+	"context"
+	"slices"
+	"time"
+
+	abcitypes "github.com/cometbft/cometbft/abci/types"
+	"github.com/palantir/stacktrace"
+)
+
+// InitChain implements [types.Application].
+func (d *DIDPLCApplication) InitChain(context.Context, *abcitypes.RequestInitChain) (*abcitypes.ResponseInitChain, error) {
+	// TODO
+	return &abcitypes.ResponseInitChain{}, nil
+}
+
+// PrepareProposal implements [types.Application].
+func (d *DIDPLCApplication) PrepareProposal(ctx context.Context, req *abcitypes.RequestPrepareProposal) (*abcitypes.ResponsePrepareProposal, error) {
+	defer d.tree.Rollback()
+
+	st := time.Now()
+	acceptedTx := make([][]byte, 0, len(req.Txs))
+	toProcess := req.Txs
+	for {
+		toTryNext := [][]byte{}
+		for _, tx := range toProcess {
+			result, err := processTx(ctx, d.plc, tx, req.Time, true)
+			if err != nil {
+				return nil, stacktrace.Propagate(err, "")
+			}
+
+			if result.Code == 0 {
+				acceptedTx = append(acceptedTx, tx)
+			} else {
+				// if a transaction is invalid, it _might_ be because it depends on a transaction that's further up in the list
+				// process it after all the others
+				toTryNext = append(toTryNext, tx)
+			}
+		}
+		if len(toProcess) == len(toTryNext) {
+			// we made no progress in this iteration - all transactions left to process fail to do so
+			// so they can't be depending on anything that would be included in this block, at this point
+			// just continue while dropping the transactions that would never succeed in this block
+			break
+		}
+		if time.Since(st) > 800*time.Millisecond {
+			// this is taking too long, just continue with what's already in acceptedTx
+			break
+		}
+		toProcess = toTryNext
+	}
+
+	return &abcitypes.ResponsePrepareProposal{Txs: acceptedTx}, nil
+}
+
+// ProcessProposal implements [types.Application].
+func (d *DIDPLCApplication) ProcessProposal(ctx context.Context, req *abcitypes.RequestProcessProposal) (*abcitypes.ResponseProcessProposal, error) {
+	// do not rollback tree in this method, in case the changes can be reused in FinalizeBlock
+	if req.Height != d.tree.WorkingVersion() {
+		// our tree went out of sync, this should never happen
+		return &abcitypes.ResponseProcessProposal{Status: abcitypes.ResponseProcessProposal_REJECT}, nil
+	}
+
+	// if we return early, ensure we don't use incomplete results where we haven't voted ACCEPT
+	d.lastProcessedProposalHash = nil
+	d.lastProcessedProposalExecTxResults = nil
+	defer func() {
+		if d.lastProcessedProposalHash == nil {
+			// we didn't vote ACCEPT
+			// we could rollback only eventually on FinalizeBlock, but why wait - rollback now for safety
+			d.tree.Rollback()
+		}
+	}()
+
+	txResults := make([]*abcitypes.ExecTxResult, len(req.Txs))
+	for i, tx := range req.Txs {
+		result, err := processTx(ctx, d.plc, tx, req.Time, true)
+		if err != nil {
+			return nil, stacktrace.Propagate(err, "")
+		}
+		for _, c := range result.TreeChanges {
+			_, err := d.tree.Set(c.Key, c.Value)
+			if err != nil {
+				return nil, stacktrace.Propagate(err, "")
+			}
+		}
+		// when preparing a proposal, invalid transactions should have been discarded
+		// so, if something doesn't succeed now, something has gone wrong and we should not vote in agreement of the proposal
+		if result.Code != 0 {
+			return &abcitypes.ResponseProcessProposal{Status: abcitypes.ResponseProcessProposal_REJECT}, nil
+		}
+
+		txResults[i] = &abcitypes.ExecTxResult{
+			Code:      result.Code,
+			Data:      result.Data,
+			Log:       result.Log,
+			Info:      result.Info,
+			GasWanted: result.GasWanted,
+			GasUsed:   result.GasUsed,
+			Events:    result.Events,
+			Codespace: result.Codespace,
+		}
+	}
+
+	d.lastProcessedProposalHash = slices.Clone(req.Hash)
+	d.lastProcessedProposalExecTxResults = txResults
+
+	return &abcitypes.ResponseProcessProposal{Status: abcitypes.ResponseProcessProposal_ACCEPT}, nil
+}
+
+// ExtendVote implements [types.Application].
+func (d *DIDPLCApplication) ExtendVote(context.Context, *abcitypes.RequestExtendVote) (*abcitypes.ResponseExtendVote, error) {
+	// TODO
+	return &abcitypes.ResponseExtendVote{}, nil
+}
+
+// VerifyVoteExtension implements [types.Application].
+func (d *DIDPLCApplication) VerifyVoteExtension(context.Context, *abcitypes.RequestVerifyVoteExtension) (*abcitypes.ResponseVerifyVoteExtension, error) {
+	// TODO
+	return &abcitypes.ResponseVerifyVoteExtension{}, nil
+}
+
+// FinalizeBlock implements [types.Application].
+func (d *DIDPLCApplication) FinalizeBlock(ctx context.Context, req *abcitypes.RequestFinalizeBlock) (*abcitypes.ResponseFinalizeBlock, error) {
+	if bytes.Equal(req.Hash, d.lastProcessedProposalHash) && d.lastProcessedProposalExecTxResults != nil {
+		// the block that was decided was the one we processed in ProcessProposal, and ProcessProposal processed successfully
+		// reuse the uncommitted results
+		return &abcitypes.ResponseFinalizeBlock{
+			TxResults: d.lastProcessedProposalExecTxResults,
+			AppHash:   d.tree.WorkingHash(),
+		}, nil
+	}
+	// a block other than the one we processed in ProcessProposal was decided
+	// discard the current modified state, and process the decided block
+	d.tree.Rollback()
+
+	txResults := make([]*abcitypes.ExecTxResult, len(req.Txs))
+	for i, tx := range req.Txs {
+		result, err := processTx(ctx, d.plc, tx, req.Time, true)
+		if err != nil {
+			return nil, stacktrace.Propagate(err, "")
+		}
+		for _, c := range result.TreeChanges {
+			_, err := d.tree.Set(c.Key, c.Value)
+			if err != nil {
+				return nil, stacktrace.Propagate(err, "")
+			}
+		}
+		txResults[i] = &abcitypes.ExecTxResult{
+			Code:      result.Code,
+			Data:      result.Data,
+			Log:       result.Log,
+			Info:      result.Info,
+			GasWanted: result.GasWanted,
+			GasUsed:   result.GasUsed,
+			Events:    result.Events,
+			Codespace: result.Codespace,
+		}
+	}
+
+	return &abcitypes.ResponseFinalizeBlock{
+		TxResults: txResults,
+		AppHash:   d.tree.WorkingHash(),
+	}, nil
+}
+
+// Commit implements [types.Application].
+func (d *DIDPLCApplication) Commit(context.Context, *abcitypes.RequestCommit) (*abcitypes.ResponseCommit, error) {
+	_, _, err := d.tree.SaveVersion()
+	if err != nil {
+		return nil, stacktrace.Propagate(err, "")
+	}
+
+	// TODO(later) consider whether we can set some RetainHeight in the response
+	return &abcitypes.ResponseCommit{}, nil
+}

abciapp/info.go

···
+package abciapp
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"net/http"
+	"net/url"
+
+	abcitypes "github.com/cometbft/cometbft/abci/types"
+	"github.com/palantir/stacktrace"
+	"github.com/ucarion/urlpath"
+	"tangled.org/gbl08ma/didplcbft/plc"
+)
+
+// Info implements [types.Application].
+func (d *DIDPLCApplication) Info(ctx context.Context, req *abcitypes.RequestInfo) (*abcitypes.ResponseInfo, error) {
+	return &abcitypes.ResponseInfo{
+		Data:             "", // TODO some status report as JSON? Information about CometBFT itself can be obtained from RequestInfo
+		Version:          "0.1.1",
+		AppVersion:       0, // TODO, included in the header of every block. move these values to constants
+		LastBlockHeight:  d.tree.Version(),
+		LastBlockAppHash: d.tree.Hash(),
+	}, nil
+}
+
+// Query implements [types.Application].
+func (d *DIDPLCApplication) Query(ctx context.Context, req *abcitypes.RequestQuery) (*abcitypes.ResponseQuery, error) {
+	url, err := url.ParseRequestURI(req.Path)
+	if err != nil || url.Host != "" || url.Scheme != "" {
+		return &abcitypes.ResponseQuery{
+			Code: 6000,
+			Info: "Invalid path",
+		}, nil
+	}
+
+	treeVersion := plc.CommittedTreeVersion
+	if req.Height != 0 {
+		treeVersion = plc.SpecificTreeVersion(req.Height)
+	}
+
+	handlers := []struct {
+		matcher urlpath.Path
+		handler func(match urlpath.Match) (*abcitypes.ResponseQuery, error)
+	}{
+		{
+			matcher: urlpath.New("/plc/:did"),
+			handler: func(match urlpath.Match) (*abcitypes.ResponseQuery, error) {
+				did := match.Params["did"]
+				doc, err := d.plc.Resolve(ctx, treeVersion, did)
+				if err != nil {
+					switch {
+					case errors.Is(err, plc.ErrDIDNotFound):
+						return &abcitypes.ResponseQuery{
+							Key:  []byte(did),
+							Code: http.StatusNotFound,
+							Info: "DID not registered: " + did,
+						}, nil
+					case errors.Is(err, plc.ErrDIDGone):
+						return &abcitypes.ResponseQuery{
+							Key:  []byte(did),
+							Code: http.StatusGone,
+							Info: "DID not available: " + did,
+						}, nil
+					default:
+						return nil, stacktrace.Propagate(err, "")
+					}
+				}
+
+				docJSON, err := json.Marshal(doc)
+				if err != nil {
+					return nil, stacktrace.Propagate(err, "")
+				}
+
+				return &abcitypes.ResponseQuery{
+					Key:   []byte(did),
+					Value: []byte(docJSON),
+					Code:  0,
+				}, nil
+			},
+		},
+		{
+			matcher: urlpath.New("/plc/:did/log"),
+			handler: func(match urlpath.Match) (*abcitypes.ResponseQuery, error) {
+				return &abcitypes.ResponseQuery{
+					Code: 1,
+					Info: "Not implemented",
+				}, nil
+			},
+		},
+		{
+			matcher: urlpath.New("/plc/:did/log/audit"),
+			handler: func(match urlpath.Match) (*abcitypes.ResponseQuery, error) {
+				return &abcitypes.ResponseQuery{
+					Code: 1,
+					Info: "Not implemented",
+				}, nil
+			},
+		},
+		{
+			matcher: urlpath.New("/plc/:did/log/last"),
+			handler: func(match urlpath.Match) (*abcitypes.ResponseQuery, error) {
+				return &abcitypes.ResponseQuery{
+					Code: 1,
+					Info: "Not implemented",
+				}, nil
+			},
+		},
+		{
+			matcher: urlpath.New("/plc/:did/data"),
+			handler: func(match urlpath.Match) (*abcitypes.ResponseQuery, error) {
+				did := match.Params["did"]
+				data, err := d.plc.Data(ctx, treeVersion, did)
+				if err != nil {
+					switch {
+					case errors.Is(err, plc.ErrDIDNotFound):
+						return &abcitypes.ResponseQuery{
+							Key:  []byte(did),
+							Code: http.StatusNotFound,
+							Info: "DID not registered: " + did,
+						}, nil
+					case errors.Is(err, plc.ErrDIDGone):
+						return &abcitypes.ResponseQuery{
+							Key:  []byte(did),
+							Code: http.StatusGone,
+							Info: "DID not available: " + did,
+						}, nil
+					default:
+						return nil, stacktrace.Propagate(err, "")
+					}
+				}
+
+				dataJSON, err := json.Marshal(&data)
+				if err != nil {
+					return nil, stacktrace.Propagate(err, "")
+				}
+
+				return &abcitypes.ResponseQuery{
+					Key:   []byte(did),
+					Value: []byte(dataJSON),
+					Code:  0,
+				}, nil
+			},
+		},
+	}
+
+	for _, h := range handlers {
+		if match, ok := h.matcher.Match(url.Path); ok {
+			return h.handler(match)
+		}
+	}
+
+	return &abcitypes.ResponseQuery{
+		Code: 6000,
+		Info: "Invalid path",
+	}, nil
+
+}

abciapp/mempool.go

···
+package abciapp
+
+import (
+	"context"
+	"time"
+
+	abcitypes "github.com/cometbft/cometbft/abci/types"
+	"github.com/palantir/stacktrace"
+)
+
+// CheckTx implements [types.Application].
+func (d *DIDPLCApplication) CheckTx(ctx context.Context, req *abcitypes.RequestCheckTx) (*abcitypes.ResponseCheckTx, error) {
+	result, err := processTx(ctx, d.plc, req.Tx, time.Now(), false)
+	if err != nil {
+		return nil, stacktrace.Propagate(err, "")
+	}
+	return &abcitypes.ResponseCheckTx{
+		Code:      result.Code,
+		Data:      result.Data,
+		Log:       result.Log,
+		Info:      result.Info,
+		GasWanted: result.GasWanted,
+		GasUsed:   result.GasUsed,
+		Events:    result.Events,
+		Codespace: result.Codespace,
+	}, nil
+}

abciapp/snapshots.go

···
+package abciapp
+
+import (
+	"bufio"
+	"bytes"
+	"context"
+	"crypto/sha256"
+	"encoding/binary"
+	"errors"
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+	"slices"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+
+	abcitypes "github.com/cometbft/cometbft/abci/types"
+	"github.com/cosmos/iavl"
+	"github.com/klauspost/compress/zstd"
+	"github.com/palantir/stacktrace"
+)
+
+const snapshotChunkSize = 10 * 1024 * 1024 // 10 MB
+const snapshotChunkHashSize = 32
+
+// ListSnapshots implements [types.Application].
+func (d *DIDPLCApplication) ListSnapshots(context.Context, *abcitypes.RequestListSnapshots) (*abcitypes.ResponseListSnapshots, error) {
+	files, err := filepath.Glob(filepath.Join(d.snapshotDirectory, "*.snapshot"))
+	if err != nil {
+		return nil, stacktrace.Propagate(err, "")
+	}
+
+	snapshots := make([]*abcitypes.Snapshot, 0, len(files))
+	for _, filename := range files {
+		s, err := readSnapshotMetadata(filename)
+		if err != nil {
+			return nil, stacktrace.Propagate(err, "")
+		}
+
+		snapshots = append(snapshots, s)
+	}
+
+	return &abcitypes.ResponseListSnapshots{
+		Snapshots: snapshots,
+	}, nil
+}
+
+func readSnapshotMetadata(filename string) (*abcitypes.Snapshot, error) {
+	// Extract height from filename pattern: %020d.snapshot
+	base := filepath.Base(filename)
+	if !strings.HasSuffix(base, ".snapshot") {
+		return nil, stacktrace.NewError("invalid snapshot filename format: %s", filename)
+	}
+	heightStr := strings.TrimSuffix(base, ".snapshot")
+	height, err := strconv.ParseInt(heightStr, 10, 64)
+	if err != nil {
+		return nil, stacktrace.Propagate(err, "failed to parse height from filename: %s", filename)
+	}
+
+	// Open and read snapshot file header
+	f, err := os.Open(filename)
+	if err != nil {
+		return nil, stacktrace.Propagate(err, "failed to open snapshot file: %s", filename)
+	}
+	defer f.Close()
+
+	// Read file magic (18 bytes)
+	magic := make([]byte, 18)
+	_, err = io.ReadFull(f, magic)
+	if err != nil {
+		return nil, stacktrace.Propagate(err, "failed to read file magic")
+	}
+	if string(magic) != "didplcbft-snapshot" {
+		return nil, stacktrace.NewError("invalid file magic: expected 'didplcbft-snapshot', got '%s'", string(magic))
+	}
+
+	// Read version bytes (6 bytes)
+	versionBytes := make([]byte, 6)
+	_, err = io.ReadFull(f, versionBytes)
+	if err != nil {
+		return nil, stacktrace.Propagate(err, "failed to read version bytes")
+	}
+	format := binary.BigEndian.Uint32(versionBytes[2:])
+
+	// Read height (8 bytes, big-endian)
+	heightBytes := make([]byte, 8)
+	_, err = io.ReadFull(f, heightBytes)
+	if err != nil {
+		return nil, stacktrace.Propagate(err, "failed to read height")
+	}
+	fileHeight := int64(binary.BigEndian.Uint64(heightBytes))
+	if fileHeight != height {
+		return nil, stacktrace.NewError("height mismatch: filename indicates %d, file header contains %d", height, fileHeight)
+	}
+
+	// Read tree hash (32 bytes)
+	hash := make([]byte, 32)
+	_, err = io.ReadFull(f, hash)
+	if err != nil {
+		return nil, stacktrace.Propagate(err, "failed to read tree hash")
+	}
+
+	// Read corresponding chunksums file
+	chunksumsFilename := strings.TrimSuffix(filename, ".snapshot") + ".chunksums"
+	chunksumsData, err := os.ReadFile(chunksumsFilename)
+	if err != nil {
+		return nil, stacktrace.Propagate(err, "failed to read chunksums file: %s", chunksumsFilename)
+	}
+
+	// Calculate number of chunks (each chunk hash is 32 bytes)
+	chunks := int64(len(chunksumsData)) / snapshotChunkHashSize
+
+	return &abcitypes.Snapshot{
+		Height:   uint64(height),
+		Format:   format,
+		Chunks:   uint32(chunks),
+		Hash:     hash,
+		Metadata: chunksumsData,
+	}, nil
+}
+
+// LoadSnapshotChunk implements [types.Application].
+func (d *DIDPLCApplication) LoadSnapshotChunk(_ context.Context, req *abcitypes.RequestLoadSnapshotChunk) (*abcitypes.ResponseLoadSnapshotChunk, error) {
+	if req.Format != 1 {
+		// just in case CometBFT asks us to load a chunk of a format we didn't declare to support in ListSnapshots...
+		return nil, stacktrace.NewError("unsupported snapshot format")
+	}
+
+	// Construct filename from height using the same pattern as createSnapshot
+	snapshotFilename := filepath.Join(d.snapshotDirectory, fmt.Sprintf("%020d.snapshot", req.Height))
+
+	// Open the snapshot file
+	f, err := os.Open(snapshotFilename)
+	if err != nil {
+		return nil, stacktrace.Propagate(err, "failed to open snapshot file: %s", snapshotFilename)
+	}
+	defer f.Close()
+
+	// Calculate the offset for the requested chunk (start from beginning of file, including header)
+	offset := int64(req.Chunk) * snapshotChunkSize
+	_, err = f.Seek(offset, io.SeekStart)
+	if err != nil {
+		return nil, stacktrace.Propagate(err, "failed to seek to chunk offset")
+	}
+
+	// Read up to snapshotChunkSize bytes
+	chunkData := make([]byte, snapshotChunkSize)
+	n, err := f.Read(chunkData)
+	if err != nil && err != io.EOF {
+		return nil, stacktrace.Propagate(err, "failed to read chunk data")
+	}
+
+	// If we read less than snapshotChunkSize, trim the slice
+	if n < snapshotChunkSize {
+		chunkData = chunkData[:n]
+	}
+
+	return &abcitypes.ResponseLoadSnapshotChunk{
+		Chunk: chunkData,
+	}, nil
+}
+
+// ApplySnapshotChunk implements [types.Application].
+func (d *DIDPLCApplication) ApplySnapshotChunk(_ context.Context, req *abcitypes.RequestApplySnapshotChunk) (*abcitypes.ResponseApplySnapshotChunk, error) {
+	if d.snapshotApplier == nil {
+		return nil, stacktrace.NewError("snapshot not offered yet, can't apply chunk")
+	}
+
+	err := d.snapshotApplier.Apply(int(req.Index), req.Chunk)
+	if err != nil {
+		fmt.Println("SNAPSHOT APPLY FAILED:", err.Error())
+		if errors.Is(err, errMalformedChunk) {
+			return &abcitypes.ResponseApplySnapshotChunk{
+				Result:        abcitypes.ResponseApplySnapshotChunk_RETRY,
+				RefetchChunks: []uint32{req.Index},
+				RejectSenders: []string{req.Sender},
+			}, nil
+		} else if errors.Is(err, errTreeHashMismatch) {
+			return &abcitypes.ResponseApplySnapshotChunk{
+				Result:        abcitypes.ResponseApplySnapshotChunk_REJECT_SNAPSHOT,
+				RejectSenders: []string{req.Sender},
+			}, nil
+		}
+		return nil, stacktrace.NewError("failed to apply")
+	}
+
+	if d.snapshotApplier.Done() {
+		d.snapshotApplier = nil
+	}
+
+	return &abcitypes.ResponseApplySnapshotChunk{
+		Result: abcitypes.ResponseApplySnapshotChunk_ACCEPT,
+	}, nil
+}
+
+// OfferSnapshot implements [types.Application].
+func (d *DIDPLCApplication) OfferSnapshot(_ context.Context, req *abcitypes.RequestOfferSnapshot) (*abcitypes.ResponseOfferSnapshot, error) {
+	if d.snapshotApplier != nil {
+		err := d.snapshotApplier.Abort()
+		if err != nil {
+			return nil, stacktrace.Propagate(err, "")
+		}
+	}
+
+	if req.Snapshot.Format != 1 {
+		return &abcitypes.ResponseOfferSnapshot{
+			Result: abcitypes.ResponseOfferSnapshot_REJECT_FORMAT,
+		}, nil
+	}
+
+	var err error
+	d.snapshotApplier, err = d.beginApplyingSnapshot(int64(req.Snapshot.Height), req.AppHash, int(req.Snapshot.Chunks), req.Snapshot.Metadata)
+	if err != nil {
+		d.snapshotApplier = nil
+		if errors.Is(err, errInvalidMetadata) {
+			return &abcitypes.ResponseOfferSnapshot{
+				Result: abcitypes.ResponseOfferSnapshot_REJECT_SENDER,
+			}, nil
+		}
+		return nil, stacktrace.Propagate(err, "")
+	}
+
+	return &abcitypes.ResponseOfferSnapshot{
+		Result: abcitypes.ResponseOfferSnapshot_ACCEPT,
+	}, nil
+}
+
+func (d *DIDPLCApplication) createSnapshot(treeVersion int64, tempFilename string) error {
+	it, err := d.tree.GetImmutable(treeVersion)
+	if err != nil {
+		return stacktrace.Propagate(err, "")
+	}
+
+	// Delete tempFilename if it exists to ensure a fresh file is created
+	_ = os.Remove(tempFilename)
+
+	f, err := os.Create(tempFilename)
+	if err != nil {
+		return stacktrace.Propagate(err, "")
+	}
+	defer f.Close()
+
+	st := time.Now()
+
+	err = writeSnapshot(f, it)
+	if err != nil {
+		return stacktrace.Propagate(err, "")
+	}
+
+	err = f.Sync()
+	if err != nil {
+		return stacktrace.Propagate(err, "")
+	}
+
+	hf, err := os.Create(filepath.Join(d.snapshotDirectory, fmt.Sprintf("%020d.chunksums", treeVersion)))
+	if err != nil {
+		return stacktrace.Propagate(err, "")
+	}
+	defer hf.Close()
+
+	err = writeChunkHashes(f, hf)
+	if err != nil {
+		return stacktrace.Propagate(err, "")
+	}
+
+	err = hf.Sync()
+	if err != nil {
+		return stacktrace.Propagate(err, "")
+	}
+
+	err = f.Close()
+	if err != nil {
+		return stacktrace.Propagate(err, "")
+	}
+
+	os.Rename(tempFilename, filepath.Join(d.snapshotDirectory, fmt.Sprintf("%020d.snapshot", treeVersion)))
+
+	fmt.Println("Took", time.Since(st), "to export")
+
+	return nil
+}
+
+func writeSnapshot(writerSeeker io.WriteSeeker, it *iavl.ImmutableTree) error {
+	writtenUntilReservedFields := 0
+
+	bw := bufio.NewWriter(writerSeeker)
+
+	// file magic and version
+	c, err := bw.Write([]byte("didplcbft-snapshot"))
+	if err != nil {
+		return stacktrace.Propagate(err, "")
+	}
+	writtenUntilReservedFields += c
+
+	c, err = bw.Write([]byte{0, 0, 0, 0, 0, 1})
+	if err != nil {
+		return stacktrace.Propagate(err, "")
+	}
+	writtenUntilReservedFields += c
+
+	b := make([]byte, 8)
+	binary.BigEndian.PutUint64(b, uint64(it.Version()))
+	c, err = bw.Write(b)
+	if err != nil {
+		return stacktrace.Propagate(err, "")
+	}
+	writtenUntilReservedFields += c
+
+	c, err = bw.Write(it.Hash())
+	if err != nil {
+		return stacktrace.Propagate(err, "")
+	}
+	writtenUntilReservedFields += c
+
+	// reserve space for writing number of bytes, number of nodes
+	// 8 bytes for node list size in bytes
+	// 8 bytes for number of nodes
+	sizeOfReservedFields := 8 + 8
+	b = make([]byte, sizeOfReservedFields)
+	_, err = bw.Write(b)
+	if err != nil {
+		return stacktrace.Propagate(err, "")
+	}
+
+	zstdw, err := zstd.NewWriter(bw, zstd.WithEncoderLevel(zstd.SpeedBetterCompression))
+	if err != nil {
+		return stacktrace.Propagate(err, "")
+	}
+
+	numNodes, err := exportNodes(it, zstdw)
+	if err != nil {
+		return stacktrace.Propagate(err, "")
+	}
+
+	err = zstdw.Close()
+	if err != nil {
+		return stacktrace.Propagate(err, "")
+	}
+
+	err = bw.Flush()
+	if err != nil {
+		return stacktrace.Propagate(err, "")
+	}
+
+	// find total compressed node list file size
+	offset, err := writerSeeker.Seek(0, io.SeekCurrent)
+	if err != nil {
+		return stacktrace.Propagate(err, "")
+	}
+	compressedNodeListSize := offset - int64(writtenUntilReservedFields) - int64(sizeOfReservedFields)
+
+	// seek back and write empty header fields
+
+	offset, err = writerSeeker.Seek(int64(writtenUntilReservedFields), io.SeekStart)
+	if err != nil {
+		return stacktrace.Propagate(err, "")
+	}
+	if offset != int64(writtenUntilReservedFields) {
+		return stacktrace.NewError("unexpected seek result")
+	}
+
+	b = make([]byte, sizeOfReservedFields)
+	binary.BigEndian.PutUint64(b, uint64(compressedNodeListSize))
+	binary.BigEndian.PutUint64(b[8:], uint64(numNodes))
+	_, err = writerSeeker.Write(b)
+	if err != nil {
+		return stacktrace.Propagate(err, "")
+	}
+
+	return nil
+}
+
+func exportNodes(it *iavl.ImmutableTree, w io.Writer) (int64, error) {
+	exporter, err := it.Export()
+	if err != nil {
+		return 0, stacktrace.Propagate(err, "")
+	}
+	defer exporter.Close()
+	cexporter := iavl.NewCompressExporter(exporter)
+
+	numNodes := int64(0)
+	for {
+		node, err := cexporter.Next()
+		if errors.Is(err, iavl.ErrorExportDone) {
+			break
+		}
+		if err != nil {
+			return 0, stacktrace.Propagate(err, "")
+		}
+
+		b := make([]byte, 9)
+		b[0] = byte(node.Height)
+
+		binary.BigEndian.PutUint64(b[1:], uint64(node.Version))
+		_, err = w.Write(b)
+		if err != nil {
+			return 0, stacktrace.Propagate(err, "")
+		}
+
+		// nil node values are different from 0-byte values
+		b = []byte{0xff, 0xff, 0xff, 0xff}
+		if node.Key != nil {
+			binary.BigEndian.PutUint32(b, uint32(len(node.Key)))
+		}
+		_, err = w.Write(b)
+		if err != nil {
+			return 0, stacktrace.Propagate(err, "")
+		}
+
+		b = []byte{0xff, 0xff, 0xff, 0xff}
+		if node.Value != nil {
+			binary.BigEndian.PutUint32(b, uint32(len(node.Value)))
+		}
+		_, err = w.Write(b)
+		if err != nil {
+			return 0, stacktrace.Propagate(err, "")
+		}
+
+		_, err = w.Write(node.Key)
+		if err != nil {
+			return 0, stacktrace.Propagate(err, "")
+		}
+
+		_, err = w.Write(node.Value)
+		if err != nil {
+			return 0, stacktrace.Propagate(err, "")
+		}
+		numNodes++
+	}
+
+	return numNodes, nil
+}
+
+func writeChunkHashes(snapshotFile io.ReadSeeker, w io.Writer) error {
+	bw := bufio.NewWriter(w)
+	defer bw.Flush()
+
+	_, err := snapshotFile.Seek(0, io.SeekStart)
+	if err != nil {
+		return stacktrace.Propagate(err, "")
+	}
+
+	buf := make([]byte, snapshotChunkSize)
+	for {
+		n, err := io.ReadFull(snapshotFile, buf)
+		if err != nil && err != io.EOF && err != io.ErrUnexpectedEOF {
+			return stacktrace.Propagate(err, "")
+		}
+		if n == 0 {
+			break
+		}
+
+		hash := sha256.Sum256(buf[:n])
+		c, err := w.Write(hash[:])
+		if err != nil {
+			return stacktrace.Propagate(err, "")
+		}
+
+		if c != snapshotChunkHashSize {
+			return stacktrace.NewError("unexpected chunk hash size")
+		}
+
+		if n < snapshotChunkSize {
+			break
+		}
+	}
+
+	return nil
+}
+
+type snapshotApplier struct {
+	tree                *iavl.MutableTree
+	treeVersion         int64
+	expectedFinalHash   []byte
+	expectedChunkHashes [][]byte
+
+	pipeWriter *io.PipeWriter
+	pipeReader *io.PipeReader
+	zstdReader io.ReadCloser
+
+	importer         *iavl.Importer
+	compressImporter iavl.NodeImporter
+	importerWg       sync.WaitGroup
+
+	numImportedNodes int
+	claimedNodeCount int
+	done             bool
+}
+
+var errMalformedChunk = errors.New("malformed chunk")
+var errInvalidMetadata = errors.New("invalid metadata")
+var errTreeHashMismatch = errors.New("tree hash mismatch")
+
+func (d *DIDPLCApplication) beginApplyingSnapshot(treeVersion int64, expectedFinalHash []byte, expectedNumChunks int, chunksums []byte) (*snapshotApplier, error) {
+	if len(chunksums)%snapshotChunkHashSize != 0 || len(chunksums)/snapshotChunkHashSize != expectedNumChunks {
+		return nil, stacktrace.Propagate(errInvalidMetadata, "")
+	}
+
+	if !d.tree.IsEmpty() {
+		err := d.fullyClearTree()
+		if err != nil {
+			return nil, stacktrace.Propagate(err, "")
+		}
+	}
+
+	importer, err := d.tree.Import(treeVersion)
+	if err != nil {
+		return nil, stacktrace.Propagate(err, "")
+	}
+
+	pipeReader, pipeWriter := io.Pipe()
+
+	zstdReader, err := zstd.NewReader(pipeReader)
+	if err != nil {
+		return nil, stacktrace.Propagate(err, "")
+	}
+
+	chunkHashes := make([][]byte, 0, expectedNumChunks)
+	for hash := range slices.Chunk(chunksums, snapshotChunkHashSize) {
+		chunkHashes = append(chunkHashes, hash)
+	}
+
+	return &snapshotApplier{
+		tree:                d.tree,
+		treeVersion:         treeVersion,
+		expectedFinalHash:   expectedFinalHash,
+		expectedChunkHashes: chunkHashes,
+
+		pipeWriter: pipeWriter,
+		pipeReader: pipeReader,
+		zstdReader: zstdReader.IOReadCloser(),
+
+		importer:         importer,
+		compressImporter: iavl.NewCompressImporter(importer),
+	}, nil
+}
+
+func (a *snapshotApplier) Apply(chunkIndex int, chunkBytes []byte) error {
+	if len(chunkBytes) > snapshotChunkSize {
+		return stacktrace.Propagate(errMalformedChunk, "chunk too large")
+	}
+	hash := sha256.Sum256(chunkBytes)
+	if !bytes.Equal(a.expectedChunkHashes[chunkIndex], hash[:]) {
+		return stacktrace.Propagate(errMalformedChunk, "hash mismatch")
+	}
+
+	if chunkIndex == 0 {
+		if len(chunkBytes) < 80 {
+			return stacktrace.Propagate(errMalformedChunk, "chunk too small")
+		}
+
+		if string(chunkBytes[0:18]) != "didplcbft-snapshot" {
+			return stacktrace.Propagate(errMalformedChunk, "invalid file magic")
+		}
+
+		if binary.BigEndian.Uint32(chunkBytes[20:]) != 1 {
+			return stacktrace.Propagate(errMalformedChunk, "invalid snapshot format")
+		}
+
+		if binary.BigEndian.Uint64(chunkBytes[24:]) != uint64(a.treeVersion) {
+			return stacktrace.Propagate(errMalformedChunk, "mismatched tree version")
+		}
+
+		if !bytes.Equal(chunkBytes[32:64], a.expectedFinalHash) {
+			return stacktrace.Propagate(errMalformedChunk, "mismatched declared tree hash")
+		}
+
+		declaredFileSize := 80 + binary.BigEndian.Uint64(chunkBytes[64:])
+		minExpectedSize := uint64((len(a.expectedChunkHashes) - 1) * snapshotChunkSize)
+		maxExpectedSize := uint64(len(a.expectedChunkHashes) * snapshotChunkSize)
+		if declaredFileSize < minExpectedSize ||
+			declaredFileSize > maxExpectedSize {
+			return stacktrace.Propagate(errMalformedChunk, "unexpected compressed node list length")
+		}
+
+		a.claimedNodeCount = int(binary.BigEndian.Uint64(chunkBytes[72:]))
+
+		// move to the start of the compressed portion
+		chunkBytes = chunkBytes[80:]
+
+		a.importerWg.Go(a.streamingImporter)
+	}
+
+	isLastChunk := chunkIndex == len(a.expectedChunkHashes)-1
+	go func(b []byte) {
+		// From the docs:
+		// It is safe to call Read and Write in parallel with each other or with Close.
+		// Parallel calls to Read and parallel calls to Write are also safe:
+		// the individual calls will be gated sequentially.
+
+		// so even if not everything gets written from this chunk (e.g. because the zstd decoder decided not to advance)
+		// it'll eventually be written, in the correct order
+		_, _ = a.pipeWriter.Write(b)
+		if isLastChunk {
+			_ = a.pipeWriter.Close()
+		}
+	}(chunkBytes)
+
+	if isLastChunk {
+		// wait for importer to finish reading and importing everything
+		a.importerWg.Wait()
+
+		if a.numImportedNodes != a.claimedNodeCount {
+			return stacktrace.Propagate(errTreeHashMismatch, "imported node count mismatch")
+		}
+
+		err := a.importer.Commit()
+		if err != nil {
+			if strings.Contains(err.Error(), "invalid node structure") {
+				return stacktrace.Propagate(errors.Join(errMalformedChunk, err), "")
+			}
+			return stacktrace.Propagate(err, "")
+		}
+
+		a.closeCommons()
+		a.done = true
+
+		if !bytes.Equal(a.tree.Hash(), a.expectedFinalHash) {
+			return stacktrace.Propagate(errTreeHashMismatch, "")
+		}
+	}
+
+	return nil
+}
+
+func (a *snapshotApplier) streamingImporter() {
+	for {
+		nodeHeader := make([]byte, 9+4+4)
+		n, err := io.ReadFull(a.zstdReader, nodeHeader)
+		if err != nil || n != 9+4+4 {
+			// err may be EOF here, which is expected
+			return
+		}
+
+		// validate lengths against sensible limits to prevent OOM DoS by malicious third parties
+		keyLength := binary.BigEndian.Uint32(nodeHeader[9:13])
+		var key []byte
+		if keyLength != 0xffffffff {
+			if keyLength > 1024*1024 {
+				return
+			}
+			key = make([]byte, keyLength)
+
+			n, err = io.ReadFull(a.zstdReader, key)
+			if err != nil || n != len(key) {
+				// this shouldn't happen unless the data is corrupt
+				// we can return silently here because since we didn't import all nodes, the tree hash won't match anyway
+				return
+			}
+		}
+
+		valueLength := binary.BigEndian.Uint32(nodeHeader[13:17])
+		var value []byte
+		if valueLength != 0xffffffff {
+			if valueLength > 1024*1024 {
+				return
+			}
+			value = make([]byte, valueLength)
+			n, err = io.ReadFull(a.zstdReader, value)
+			if err != nil || n != len(value) {
+				return
+			}
+		}
+
+		err = a.compressImporter.Add(&iavl.ExportNode{
+			Height:  int8(nodeHeader[0]),
+			Version: int64(binary.BigEndian.Uint64(nodeHeader[1:9])),
+			Key:     key,
+			Value:   value,
+		})
+		if err != nil {
+			// this shouldn't happen unless the data is corrupt
+			// we can return silently here because since we didn't import all nodes, the tree hash won't match anyway
+			return
+		}
+		a.numImportedNodes++
+	}
+}
+
+func (a *snapshotApplier) Abort() error {
+	err := a.closeCommons()
+	if err != nil {
+		return stacktrace.Propagate(err, "")
+	}
+
+	err = a.tree.DeleteVersionsFrom(0)
+	if err != nil {
+		return stacktrace.Propagate(err, "")
+	}
+
+	return nil
+}
+
+func (a *snapshotApplier) closeCommons() error {
+	err := a.zstdReader.Close()
+	if err != nil {
+		return stacktrace.Propagate(err, "")
+	}
+
+	err = a.pipeReader.Close()
+	if err != nil {
+		return stacktrace.Propagate(err, "")
+	}
+
+	err = a.pipeWriter.Close()
+	if err != nil {
+		return stacktrace.Propagate(err, "")
+	}
+
+	a.importerWg.Wait()
+	a.importer.Close()
+
+	return nil
+}
+
+func (a *snapshotApplier) Done() bool {
+	return a.done
+}

abciapp/tx.go

···
+package abciapp
+
+import (
+	"bytes"
+	"context"
+	"time"
+
+	abcitypes "github.com/cometbft/cometbft/abci/types"
+	cbornode "github.com/ipfs/go-ipld-cbor"
+	"github.com/palantir/stacktrace"
+	"tangled.org/gbl08ma/didplcbft/plc"
+)
+
+type ArgumentType interface {
+	ForAction() TransactionAction
+}
+
+type TransactionAction string
+
+var (
+	knownActions                 = map[TransactionAction]struct{}{}
+	TransactionActionCreatePlcOp = registerTransactionAction[CreatePlcOpArguments]("CreatePlcOp")
+)
+
+func registerTransactionAction[ArgType ArgumentType](action string) TransactionAction {
+	ta := TransactionAction(action)
+	if _, present := knownActions[ta]; present {
+		panic("action already registered")
+	}
+	var argType ArgType
+	if argType.ForAction() != "" && argType.ForAction() != ta {
+		panic("mismatched argument types")
+	}
+	knownActions[ta] = struct{}{}
+	return ta
+}
+
+type Transaction[ArgType any] struct {
+	Action    TransactionAction `json:"action" refmt:"action"`
+	Arguments ArgType           `json:"arguments,omitempty" refmt:"arguments,omitempty"`
+}
+
+func UnmarshalTransaction[ArgType ArgumentType](txBytes []byte) (Transaction[ArgType], error) {
+	var t Transaction[ArgType]
+	err := cbornode.DecodeInto(txBytes, &t)
+	if err != nil {
+		return Transaction[ArgType]{}, stacktrace.Propagate(err, "")
+	}
+
+	var argType ArgType
+	if argType.ForAction() != t.Action {
+		return Transaction[ArgType]{}, stacktrace.NewError("mismatched argument types")
+	}
+
+	return t, nil
+}
+
+// SanitizeTransaction should always be called to obtain the canonical bytes of a transaction
+func SanitizeTransaction(txBytes []byte) ([]byte, error) {
+	var v any
+	err := cbornode.DecodeInto(txBytes, &v)
+	if err != nil {
+		return nil, stacktrace.Propagate(err, "invalid transaction")
+	}
+	b, err := cbornode.DumpObject(v)
+	if err != nil {
+		return nil, stacktrace.Propagate(err, "")
+	}
+	return b, nil
+}
+
+func IsTransactionSanitized(txBytes []byte) bool {
+	s, err := SanitizeTransaction(txBytes)
+	if err != nil {
+		return false
+	}
+	return bytes.Equal(txBytes, s)
+}
+
+type treeChange struct {
+	Key   []byte
+	Value []byte
+}
+type processResult struct {
+	TreeChanges []treeChange
+	Code        uint32
+	Data        []byte
+	Log         string
+	Info        string
+	GasWanted   int64
+	GasUsed     int64
+	Events      []abcitypes.Event
+	Codespace   string
+}
+
+func processTx(ctx context.Context, p plc.PLC, txBytes []byte, atTime time.Time, execute bool) (*processResult, error) {
+	if !IsTransactionSanitized(txBytes) {
+		return &processResult{
+			Code: 4000,
+			Info: "Transaction bytes do not follow canonical serialization format",
+		}, nil
+	}
+	var v map[string]interface{}
+	err := cbornode.DecodeInto(txBytes, &v)
+	if err != nil {
+		return &processResult{
+			Code: 4001,
+			Info: "Invalid transaction",
+		}, nil
+	}
+	actionInterface, ok := v["action"]
+	if !ok {
+		return &processResult{
+			Code: 4001,
+			Info: "Unknown transaction action",
+		}, nil
+	}
+	action, ok := actionInterface.(string)
+	if !ok {
+		return &processResult{
+			Code: 4001,
+			Info: "Unknown transaction action",
+		}, nil
+	}
+
+	switch TransactionAction(action) {
+	case TransactionActionCreatePlcOp:
+		result, err := processCreatePlcOpTx(ctx, p, txBytes, atTime, execute)
+		return result, stacktrace.Propagate(err, "")
+	default:
+		return &processResult{
+			Code: 4001,
+			Info: "Unknown transaction action",
+		}, nil
+	}
+}

abciapp/tx_create_plc_op.go

···
+package abciapp
+
+import (
+	"context"
+	"encoding/json"
+	"time"
+
+	"github.com/did-method-plc/go-didplc"
+	"github.com/ipfs/go-cid"
+	cbornode "github.com/ipfs/go-ipld-cbor"
+	"github.com/palantir/stacktrace"
+	"tangled.org/gbl08ma/didplcbft/plc"
+)
+
+type CreatePlcOpArguments struct {
+	DID       string         `json:"did" refmt:"did"`
+	Operation *didplc.OpEnum `refmt:"operation"`
+}
+
+func (CreatePlcOpArguments) ForAction() TransactionAction {
+	return TransactionActionCreatePlcOp
+}
+
+func init() {
+	cbornode.RegisterCborType(CreatePlcOpArguments{})
+	cbornode.RegisterCborType(Transaction[CreatePlcOpArguments]{})
+}
+
+func processCreatePlcOpTx(ctx context.Context, p plc.PLC, txBytes []byte, atTime time.Time, execute bool) (*processResult, error) {
+	tx, err := UnmarshalTransaction[CreatePlcOpArguments](txBytes)
+	if err != nil {
+		return &processResult{
+			Code: 4000,
+			Info: err.Error(),
+		}, nil
+	}
+
+	// sadly didplc is really designed to unmarshal JSON, not CBOR
+	// so JSON ends up being the lingua franca for operations inside our PLC implementation too
+	// we also can't instance didplc.Operations directly from the CBOR unmarshaller (the MakeUnmarshalTransformFunc thing)
+	// because the interface makes us lose data (it is not powerful enough to detect the type of a transaction, for instance)
+	// so our PLC internals end up depending on OpEnum, too
+	// the decision to use CBOR for the entire thing at the blockchain transaction level is:
+	// - to make transactions more compact
+	// - to have more of a canonical format for them (we specifically use the stable CBOR format already used by the PLC for signing)
+
+	// there is one advantage to this approach: by ensuring we first unmarshal the operations into strongly defined types
+	// (e.g. the OpEnum struct of the didplc package)
+	// we avoid accepting malformed data like what happened in https://github.com/did-method-plc/did-method-plc/issues/71
+	opBytes, err := json.Marshal(tx.Arguments.Operation)
+	if err != nil {
+		return nil, stacktrace.Propagate(err, "internal error")
+	}
+
+	var cid cid.Cid
+	if execute {
+		cid, err = p.ExecuteOperation(ctx, atTime, tx.Arguments.DID, opBytes)
+	} else {
+		err = p.ValidateOperation(ctx, plc.CommittedTreeVersion, atTime, tx.Arguments.DID, opBytes)
+	}
+	if err != nil {
+		if code, ok := plc.InvalidOperationErrorCode(err); ok {
+			return &processResult{
+				Code: code,
+				Info: err.Error(),
+			}, nil
+		}
+		return nil, stacktrace.Propagate(err, "internal error")
+	}
+
+	return &processResult{
+		TreeChanges: []treeChange{{
+			Key:   []byte(tx.Arguments.DID),
+			Value: cid.Bytes(),
+		}},
+		Code: 0,
+	}, nil
+}

badgeradapter/adapter.go

···
+package badgeradapter
+
+import (
+	"bytes"
+	"slices"
+
+	"cosmossdk.io/core/store"
+	"github.com/cosmos/iavl/db"
+	"github.com/palantir/stacktrace"
+
+	badger "github.com/dgraph-io/badger/v4"
+)
+
+type BadgerAdapter struct {
+	badgerDB  *badger.DB
+	keyPrefix []byte
+}
+
+func AdaptBadger(badgerDB *badger.DB, keyPrefix []byte) *BadgerAdapter {
+	return &BadgerAdapter{
+		badgerDB:  badgerDB,
+		keyPrefix: keyPrefix,
+	}
+}
+
+var _ db.DB = (*BadgerAdapter)(nil)
+
+// prefixKey adds the keyPrefix to the given key
+func (b *BadgerAdapter) prefixKey(key []byte) []byte {
+	result := make([]byte, 0, len(b.keyPrefix)+len(key))
+	result = append(result, b.keyPrefix...)
+	result = append(result, key...)
+	return result
+}
+
+// Close implements [db.DB].
+func (b *BadgerAdapter) Close() error {
+	return b.badgerDB.Close()
+}
+
+// Get implements [db.DB].
+func (b *BadgerAdapter) Get(key []byte) ([]byte, error) {
+	prefixedKey := b.prefixKey(key)
+
+	var value []byte
+	err := b.badgerDB.View(func(txn *badger.Txn) error {
+		item, err := txn.Get(prefixedKey)
+		if err != nil {
+			return err
+		}
+		value, err = item.ValueCopy(nil)
+		return err
+	})
+
+	if err == badger.ErrKeyNotFound {
+		return nil, nil
+	}
+	if err != nil {
+		return nil, stacktrace.Propagate(err, "failed to get key from badger")
+	}
+
+	return value, nil
+}
+
+// Has implements [db.DB].
+func (b *BadgerAdapter) Has(key []byte) (bool, error) {
+	prefixedKey := b.prefixKey(key)
+
+	var has bool
+	err := b.badgerDB.View(func(txn *badger.Txn) error {
+		_, err := txn.Get(prefixedKey)
+		if err == badger.ErrKeyNotFound {
+			has = false
+			return nil
+		}
+		if err != nil {
+			return err
+		}
+		has = true
+		return nil
+	})
+
+	if err != nil {
+		return false, stacktrace.Propagate(err, "failed to check key existence in badger")
+	}
+
+	return has, nil
+}
+
+// BadgerIterator adapts badger.Iterator to store.Iterator
+type BadgerIterator struct {
+	badgerIter *badger.Iterator
+	txn        *badger.Txn
+	start      []byte
+	end        []byte
+	reverse    bool // true if this is a reverse iterator
+	valid      bool
+	keyPrefix  []byte
+}
+
+// hasPrefix checks if a prefixed key actually has the expected keyPrefix
+func (i *BadgerIterator) hasPrefix(prefixedKey []byte) bool {
+	return len(prefixedKey) >= len(i.keyPrefix) && bytes.Equal(prefixedKey[:len(i.keyPrefix)], i.keyPrefix)
+}
+
+// stripPrefix removes the keyPrefix from a prefixed key
+func (i *BadgerIterator) stripPrefix(prefixedKey []byte) []byte {
+	if len(prefixedKey) < len(i.keyPrefix) {
+		return prefixedKey // Shouldn't happen, but defensive programming
+	}
+	stripped := make([]byte, len(prefixedKey)-len(i.keyPrefix))
+	copy(stripped, prefixedKey[len(i.keyPrefix):])
+	return stripped
+}
+
+func (i *BadgerIterator) Domain() (start, end []byte) {
+	// Return copies to ensure they're safe for modification
+	startCopy := make([]byte, len(i.start))
+	endCopy := make([]byte, len(i.end))
+	copy(startCopy, i.start)
+	copy(endCopy, i.end)
+	return startCopy, endCopy
+}
+
+func (i *BadgerIterator) Valid() bool {
+	if !i.valid || !i.badgerIter.Valid() {
+		return false
+	}
+
+	// Ensure the current key has the correct keyPrefix
+	// If not, skip to the next valid key
+	item := i.badgerIter.Item()
+	prefixedKey := item.Key()
+	if !i.hasPrefix(prefixedKey) {
+		// We've gone out of the bounds of "our" prefixes
+		return false
+	}
+
+	// For forward iteration, check if we've reached the end (end is exclusive)
+	if i.end != nil && !i.reverse {
+		currentKey := i.stripPrefix(prefixedKey)
+		// If current key >= end key, we're done
+		if bytes.Compare(currentKey, i.end) >= 0 {
+			return false
+		}
+	}
+
+	// For reverse iteration, check if we've gone below the start (start is inclusive)
+	if i.start != nil && i.reverse {
+		currentKey := i.stripPrefix(prefixedKey)
+		// If current key < start key, we're done
+		if bytes.Compare(currentKey, i.start) < 0 {
+			return false
+		}
+	}
+
+	return true
+}
+
+func (i *BadgerIterator) Next() {
+	if !i.valid {
+		panic("iterator is not valid")
+	}
+	i.badgerIter.Next()
+
+	// Check if the badger iterator is still valid
+	if !i.badgerIter.Valid() {
+		i.valid = false
+		return
+	}
+
+	item := i.badgerIter.Item()
+	prefixedKey := item.Key()
+	if !i.hasPrefix(prefixedKey) {
+		// We've gone out of the bounds of "our" prefixes
+		i.valid = false
+		return
+	}
+
+	// For forward iteration, check if we've reached the end (end is exclusive)
+	if i.end != nil && !i.reverse {
+		currentKey := i.stripPrefix(prefixedKey)
+		// If current key >= end key, we're done
+		if bytes.Compare(currentKey, i.end) >= 0 {
+			i.valid = false
+			return
+		}
+	}
+
+	// For reverse iteration, check if we've gone below the start (start is inclusive)
+	if i.start != nil && i.reverse {
+		currentKey := i.stripPrefix(prefixedKey)
+		// If current key < start key, we're done
+		if bytes.Compare(currentKey, i.start) < 0 {
+			i.valid = false
+			return
+		}
+	}
+
+	i.valid = true
+}
+
+func (i *BadgerIterator) Key() []byte {
+	if !i.valid {
+		panic("iterator is not valid")
+	}
+	item := i.badgerIter.Item()
+	return i.stripPrefix(item.Key())
+}
+
+func (i *BadgerIterator) Value() []byte {
+	if !i.valid {
+		panic("iterator is not valid")
+	}
+	item := i.badgerIter.Item()
+	value, err := item.ValueCopy(nil)
+	if err != nil {
+		panic("failed to copy value: " + err.Error())
+	}
+	return value
+}
+
+func (i *BadgerIterator) Error() error {
+	// Badger iterator doesn't have a separate error method
+	// Errors are typically caught during iteration setup
+	return nil
+}
+
+func (i *BadgerIterator) Close() error {
+	// Close the badger iterator first - this is critical to avoid panics
+	if i.badgerIter != nil {
+		i.badgerIter.Close()
+	}
+
+	// Mark as invalid
+	i.valid = false
+
+	// Discard the transaction to release resources
+	if i.txn != nil {
+		i.txn.Discard()
+		i.txn = nil
+	}
+
+	return nil
+}
+
+// Iterator implements [db.DB].
+func (b *BadgerAdapter) Iterator(start []byte, end []byte) (store.Iterator, error) {
+	// Create a read-only transaction to hold the iterator
+	txn := b.badgerDB.NewTransaction(false)
+
+	// Create prefixed version of start
+	prefixedStart := b.prefixKey(start)
+
+	opts := badger.IteratorOptions{
+		PrefetchValues: true,
+		Reverse:        false,
+		AllVersions:    false,
+	}
+	badgerIter := txn.NewIterator(opts)
+
+	badgerIter.Seek(prefixedStart)
+
+	iterator := &BadgerIterator{
+		badgerIter: badgerIter,
+		txn:        txn,
+		start:      start, // Store original start/end for Domain() method
+		end:        end,
+		reverse:    false, // This is a forward iterator
+		valid:      badgerIter.Valid(),
+		keyPrefix:  b.keyPrefix,
+	}
+
+	return iterator, nil
+}
+
+// incrementSlice assumes that the first byte of b is not 0xff
+func incrementSlice(b []byte) {
+	for i := len(b) - 1; i >= 0; i-- {
+		b[i] += 1
+		if b[i] != 0 {
+			break
+		}
+	}
+}
+
+// ReverseIterator implements [db.DB].
+func (b *BadgerAdapter) ReverseIterator(start []byte, end []byte) (store.Iterator, error) {
+	// Create a read-only transaction to hold the iterator
+	txn := b.badgerDB.NewTransaction(false)
+
+	opts := badger.IteratorOptions{
+		PrefetchValues: true,
+		Reverse:        true, // This enables reverse iteration
+		AllVersions:    false,
+	}
+	badgerIter := txn.NewIterator(opts)
+
+	prefixedEnd := b.prefixKey(end)
+	incrementedEnd := slices.Clone(prefixedEnd)
+	incrementSlice(incrementedEnd) // Badger's Seek is inclusive but in these iterators end is exclusive (except if nil)
+
+	badgerIter.Seek(incrementedEnd)
+	// if end is nil, then Badger might be (depending on whether end matches an existing key)
+	// already giving us the key we want and there's no need to skip
+	if end != nil && badgerIter.Valid() && bytes.Equal(badgerIter.Item().Key(), prefixedEnd) {
+		badgerIter.Next()
+	}
+
+	iterator := &BadgerIterator{
+		badgerIter: badgerIter,
+		txn:        txn,
+		start:      start,
+		end:        end,
+		reverse:    true, // This is a reverse iterator
+		valid:      badgerIter.Valid(),
+		keyPrefix:  b.keyPrefix,
+	}
+
+	return iterator, nil
+}
+
+// BadgerBatch implements store.Batch
+// BadgerBatch writes are atomic up until the point where they'd exceed the badger max transaction size,
+// at which point they are split into multiple non-atomic writes
+type BadgerBatch struct {
+	wb        *badger.WriteBatch
+	closed    bool
+	keyPrefix []byte
+}
+
+func (b *BadgerBatch) Set(key, value []byte) error {
+	if b.closed {
+		return stacktrace.NewError("batch has been written or closed")
+	}
+	if len(key) == 0 {
+		return stacktrace.NewError("key cannot be empty")
+	}
+	if value == nil {
+		return stacktrace.NewError("value cannot be nil")
+	}
+
+	prefixedKey := make([]byte, 0, len(b.keyPrefix)+len(key))
+	prefixedKey = append(prefixedKey, b.keyPrefix...)
+	prefixedKey = append(prefixedKey, key...)
+
+	err := b.wb.Set(prefixedKey, value)
+	return stacktrace.Propagate(err, "failed to set key in batch")
+}
+
+func (b *BadgerBatch) Delete(key []byte) error {
+	if b.closed {
+		return stacktrace.NewError("batch has been written or closed")
+	}
+	if len(key) == 0 {
+		return stacktrace.NewError("key cannot be empty")
+	}
+
+	prefixedKey := make([]byte, 0, len(b.keyPrefix)+len(key))
+	prefixedKey = append(prefixedKey, b.keyPrefix...)
+	prefixedKey = append(prefixedKey, key...)
+
+	err := b.wb.Delete(prefixedKey)
+	return stacktrace.Propagate(err, "failed to delete key in batch")
+}
+
+func (b *BadgerBatch) Write() error {
+	if b.closed {
+		return stacktrace.NewError("batch has been written or closed")
+	}
+	b.closed = true
+	err := b.wb.Flush()
+	return stacktrace.Propagate(err, "failed to write batch")
+}
+
+func (b *BadgerBatch) WriteSync() error {
+	// Badger doesn't have separate WriteSync, so we just use Write
+	return b.Write()
+}
+
+func (b *BadgerBatch) Close() error {
+	if !b.closed {
+		b.wb.Cancel()
+		b.closed = true
+	}
+	return nil
+}
+
+func (b *BadgerBatch) GetByteSize() (int, error) {
+	// Badger doesn't provide byte size tracking for batches
+	// Return 0 as a placeholder
+	return 0, nil
+}
+
+// NewBatch implements [db.DB].
+func (b *BadgerAdapter) NewBatch() store.Batch {
+	return &BadgerBatch{
+		wb:        b.badgerDB.NewWriteBatch(),
+		keyPrefix: b.keyPrefix,
+	}
+}
+
+// NewBatchWithSize implements [db.DB].
+func (b *BadgerAdapter) NewBatchWithSize(size int) store.Batch {
+	// Badger doesn't support pre-allocated batch sizes, so we just create a regular batch
+	return b.NewBatch()
+}

badgeradapter/adapter_test.go

···
+package badgeradapter
+
+import (
+	"testing"
+
+	badger "github.com/dgraph-io/badger/v4"
+	"github.com/stretchr/testify/require"
+)
+
+func TestBadgerAdapter_KeyPrefixStripping(t *testing.T) {
+	// Create a temporary badger database
+	opts := badger.DefaultOptions("").WithInMemory(true)
+	db, err := badger.Open(opts)
+	require.NoError(t, err)
+	defer db.Close()
+
+	// Create adapter with a specific key prefix
+	keyPrefix := []byte("test:")
+	adapter := AdaptBadger(db, keyPrefix)
+
+	// Write some test data
+	batch := adapter.NewBatch()
+	err = batch.Set([]byte("key1"), []byte("value1"))
+	require.NoError(t, err)
+	err = batch.Write()
+	require.NoError(t, err)
+
+	// Verify that the underlying badger database stores the key WITH the prefix
+	var foundPrefixedKey bool
+	err = db.View(func(txn *badger.Txn) error {
+		opts := badger.IteratorOptions{
+			PrefetchValues: true,
+			Reverse:        false,
+			AllVersions:    false,
+		}
+		iter := txn.NewIterator(opts)
+		defer iter.Close()
+
+		for iter.Seek([]byte("test:")); iter.Valid(); iter.Next() {
+			item := iter.Item()
+			key := item.KeyCopy(nil)
+			if string(key) == "test:key1" {
+				foundPrefixedKey = true
+				value, err := item.ValueCopy(nil)
+				require.NoError(t, err)
+				require.Equal(t, []byte("value1"), value)
+				break
+			}
+		}
+		return nil
+	})
+	require.NoError(t, err)
+	require.True(t, foundPrefixedKey, "Expected to find prefixed key 'test:key1' in underlying badger database")
+
+	// Test Get operation - should work with unprefixed key
+	value, err := adapter.Get([]byte("key1"))
+	require.NoError(t, err)
+	require.Equal(t, []byte("value1"), value)
+
+	// Test iterator - should iterate over prefixed keys but return unprefixed keys
+	iter, err := adapter.Iterator([]byte("key1"), []byte("key2"))
+	require.NoError(t, err)
+	defer iter.Close()
+
+	require.True(t, iter.Valid())
+	returnedKey := iter.Key()
+	returnedValue := iter.Value()
+
+	// The returned key should NOT have the prefix
+	require.Equal(t, []byte("key1"), returnedKey)
+	require.Equal(t, []byte("value1"), returnedValue)
+
+	iter.Next()
+	require.False(t, iter.Valid())
+}
+
+func TestBadgerAdapter_ReverseIteratorPrefixStripping(t *testing.T) {
+	// Create a temporary badger database
+	opts := badger.DefaultOptions("").WithInMemory(true)
+	db, err := badger.Open(opts)
+	require.NoError(t, err)
+	defer db.Close()
+
+	// Create adapter with a specific key prefix
+	keyPrefix := []byte("prefix:")
+	adapter := AdaptBadger(db, keyPrefix)
+
+	// Write multiple test data entries
+	batch := adapter.NewBatch()
+	for i := 1; i <= 3; i++ {
+		key := []byte("key" + string(rune('0'+i)))
+		value := []byte("value" + string(rune('0'+i)))
+		err = batch.Set(key, value)
+		require.NoError(t, err)
+	}
+	err = batch.Write()
+	require.NoError(t, err)
+
+	// Verify that the underlying badger database stores the keys WITH the prefix
+	var foundPrefixedKeys []string
+	err = db.View(func(txn *badger.Txn) error {
+		opts := badger.IteratorOptions{
+			PrefetchValues: true,
+			Reverse:        false,
+			AllVersions:    false,
+		}
+		iter := txn.NewIterator(opts)
+		defer iter.Close()
+
+		for iter.Seek([]byte("prefix:")); iter.Valid(); iter.Next() {
+			item := iter.Item()
+			key := item.KeyCopy(nil)
+			keyStr := string(key)
+			if len(keyStr) > len("prefix:") && keyStr[:len("prefix:")] == "prefix:" {
+				foundPrefixedKeys = append(foundPrefixedKeys, keyStr)
+			}
+		}
+		return nil
+	})
+	require.NoError(t, err)
+	require.Len(t, foundPrefixedKeys, 3, "Expected to find 3 prefixed keys in underlying badger database")
+	require.Contains(t, foundPrefixedKeys, "prefix:key1")
+	require.Contains(t, foundPrefixedKeys, "prefix:key2")
+	require.Contains(t, foundPrefixedKeys, "prefix:key3")
+
+	// Test reverse iterator - should iterate over prefixed keys but return unprefixed keys
+	iter, err := adapter.ReverseIterator([]byte("key1"), []byte("key4"))
+	require.NoError(t, err)
+	defer iter.Close()
+
+	// Should start with the last key in range
+	require.True(t, iter.Valid())
+	returnedKey := iter.Key()
+	returnedValue := iter.Value()
+
+	// The returned key should NOT have the prefix
+	require.Equal(t, []byte("key3"), returnedKey)
+	require.Equal(t, []byte("value3"), returnedValue)
+
+	// Move to previous key
+	iter.Next()
+	require.True(t, iter.Valid())
+	returnedKey = iter.Key()
+	returnedValue = iter.Value()
+	require.Equal(t, []byte("key2"), returnedKey)
+	require.Equal(t, []byte("value2"), returnedValue)
+
+	// Move to previous key again
+	iter.Next()
+	require.True(t, iter.Valid())
+	returnedKey = iter.Key()
+	returnedValue = iter.Value()
+	require.Equal(t, []byte("key1"), returnedKey)
+	require.Equal(t, []byte("value1"), returnedValue)
+
+	// Should be at the beginning of range
+	iter.Next()
+	require.False(t, iter.Valid())
+}
+
+func TestBadgerAdapter_IteratorRespectsEnd(t *testing.T) {
+	// Create a temporary badger database
+	opts := badger.DefaultOptions("").WithInMemory(true)
+	db, err := badger.Open(opts)
+	require.NoError(t, err)
+	defer db.Close()
+
+	// Create adapter with a specific key prefix
+	keyPrefix := []byte("test:")
+	adapter := AdaptBadger(db, keyPrefix)
+
+	// Write test data
+	batch := adapter.NewBatch()
+	data := map[string]string{
+		"apple":      "fruit1",
+		"banana":     "fruit2",
+		"cherry":     "fruit3",
+		"date":       "fruit4",
+		"elderberry": "fruit5",
+	}
+	for key, value := range data {
+		err = batch.Set([]byte(key), []byte(value))
+		require.NoError(t, err)
+	}
+	err = batch.Write()
+	require.NoError(t, err)
+
+	// Test forward iteration with end boundary
+	iter, err := adapter.Iterator([]byte("apple"), []byte("cherry"))
+	require.NoError(t, err)
+	defer iter.Close()
+
+	// Should include "apple" and "banana" but stop before "cherry"
+	require.True(t, iter.Valid())
+	require.Equal(t, []byte("apple"), iter.Key())
+	require.Equal(t, []byte("fruit1"), iter.Value())
+
+	iter.Next()
+	require.True(t, iter.Valid())
+	require.Equal(t, []byte("banana"), iter.Key())
+	require.Equal(t, []byte("fruit2"), iter.Value())
+
+	// Next should stop before "cherry" since end is exclusive
+	iter.Next()
+	require.False(t, iter.Valid(), "Iterator should be invalid after reaching end boundary")
+
+	// Test forward iteration with nil end (should iterate to the end)
+	iter, err = adapter.Iterator([]byte("apple"), nil)
+	require.NoError(t, err)
+	defer iter.Close()
+
+	count := 0
+	for iter.Valid() {
+		count++
+		iter.Next()
+	}
+	require.Equal(t, 5, count, "Should iterate over all 5 keys when end is nil")
+
+	// Test forward iteration with start = nil (should start from first key)
+	iter, err = adapter.Iterator(nil, []byte("cherry"))
+	require.NoError(t, err)
+	defer iter.Close()
+
+	count = 0
+	for iter.Valid() {
+		count++
+		iter.Next()
+	}
+	require.Equal(t, 2, count, "Should iterate over 2 keys (apple, banana) before cherry")
+}
+
+func TestBadgerAdapter_ReverseIteratorRespectsStart(t *testing.T) {
+	// Create a temporary badger database
+	opts := badger.DefaultOptions("").WithInMemory(true)
+	db, err := badger.Open(opts)
+	require.NoError(t, err)
+	defer db.Close()
+
+	// Create adapter with a specific key prefix
+	keyPrefix := []byte("test:")
+	adapter := AdaptBadger(db, keyPrefix)
+
+	// Write test data
+	batch := adapter.NewBatch()
+	data := map[string]string{
+		"apple":      "fruit1",
+		"banana":     "fruit2",
+		"cherry":     "fruit3",
+		"date":       "fruit4",
+		"elderberry": "fruit5",
+	}
+	for key, value := range data {
+		err = batch.Set([]byte(key), []byte(value))
+		require.NoError(t, err)
+	}
+	err = batch.Write()
+	require.NoError(t, err)
+
+	// Test reverse iteration with start boundary
+	iter, err := adapter.ReverseIterator([]byte("banana"), []byte("elderberry"))
+	require.NoError(t, err)
+	defer iter.Close()
+
+	// Should start from "date" and go backwards to "banana" (inclusive)
+	require.True(t, iter.Valid())
+	require.Equal(t, []byte("date"), iter.Key())
+	require.Equal(t, []byte("fruit4"), iter.Value())
+
+	iter.Next()
+	require.True(t, iter.Valid())
+	require.Equal(t, []byte("cherry"), iter.Key())
+	require.Equal(t, []byte("fruit3"), iter.Value())
+
+	iter.Next()
+	require.True(t, iter.Valid())
+	require.Equal(t, []byte("banana"), iter.Key())
+	require.Equal(t, []byte("fruit2"), iter.Value())
+
+	// Next should stop since we've reached the start boundary (inclusive)
+	iter.Next()
+	require.False(t, iter.Valid(), "Iterator should be invalid after reaching start boundary")
+
+	// Test reverse iteration with nil start (should go to the beginning)
+	iter, err = adapter.ReverseIterator(nil, []byte("cherry"))
+	require.NoError(t, err)
+	defer iter.Close()
+
+	count := 0
+	for iter.Valid() {
+		count++
+		iter.Next()
+	}
+	require.Equal(t, 2, count, "Should iterate over 2 keys (banana, apple) before cherry")
+
+	// Test reverse iteration with nil end (should start from the last key)
+	iter, err = adapter.ReverseIterator([]byte("banana"), nil)
+	require.NoError(t, err)
+	defer iter.Close()
+
+	count = 0
+	for iter.Valid() {
+		count++
+		iter.Next()
+	}
+	require.Equal(t, 4, count, "Should iterate over 4 keys (elderberry, date, cherry, banana) when end is nil")
+}
+
+func TestBadgerAdapter_IteratorRespectsKeyPrefix(t *testing.T) {
+	// Create a temporary badger database
+	opts := badger.DefaultOptions("").WithInMemory(true)
+	db, err := badger.Open(opts)
+	require.NoError(t, err)
+	defer db.Close()
+
+	// Create adapter with a specific key prefix
+	keyPrefix := []byte("table1:")
+	adapter := AdaptBadger(db, keyPrefix)
+
+	// Write test data directly to badger with different prefixes to simulate multiple "tables"
+	err = db.Update(func(txn *badger.Txn) error {
+		// Write keys with the correct prefix (what the adapter should see)
+		err := txn.Set([]byte("table1:apple"), []byte("fruit1"))
+		require.NoError(t, err)
+		err = txn.Set([]byte("table1:banana"), []byte("fruit2"))
+		require.NoError(t, err)
+		err = txn.Set([]byte("table1:cherry"), []byte("fruit3"))
+		require.NoError(t, err)
+
+		// Write keys with a different prefix (what the adapter should NOT see)
+		err = txn.Set([]byte("table2:apple"), []byte("other1"))
+		require.NoError(t, err)
+		err = txn.Set([]byte("table2:date"), []byte("other2"))
+		require.NoError(t, err)
+
+		// Write keys with no prefix (what the adapter should NOT see)
+		err = txn.Set([]byte("apple"), []byte("raw1"))
+		require.NoError(t, err)
+		err = txn.Set([]byte("zebra"), []byte("raw2"))
+		require.NoError(t, err)
+
+		return nil
+	})
+	require.NoError(t, err)
+
+	// Test forward iteration - should only see keys with "table1:" prefix
+	iter, err := adapter.Iterator(nil, nil)
+	require.NoError(t, err)
+	defer iter.Close()
+
+	var keys []string
+	for iter.Valid() {
+		keys = append(keys, string(iter.Key()))
+		iter.Next()
+	}
+
+	// Should only see the 3 keys with the correct prefix, stripped of the prefix
+	require.Equal(t, []string{"apple", "banana", "cherry"}, keys)
+
+	// Test forward iteration with range - should only see keys with "table1:" prefix in range
+	iter, err = adapter.Iterator([]byte("banana"), []byte("cherry"))
+	require.NoError(t, err)
+	defer iter.Close()
+
+	keys = nil
+	for iter.Valid() {
+		keys = append(keys, string(iter.Key()))
+		iter.Next()
+	}
+
+	// Should only see "banana" (inclusive) but not "cherry" (exclusive)
+	require.Equal(t, []string{"banana"}, keys)
+
+	// Test reverse iteration - should only see keys with "table1:" prefix
+	iter, err = adapter.ReverseIterator(nil, nil)
+	require.NoError(t, err)
+	defer iter.Close()
+
+	keys = nil
+	for iter.Valid() {
+		keys = append(keys, string(iter.Key()))
+		iter.Next()
+	}
+
+	// Should see the 3 keys in reverse order, stripped of the prefix
+	require.Equal(t, []string{"cherry", "banana", "apple"}, keys)
+
+	// Test reverse iteration with range - should only see keys with "table1:" prefix in range
+	iter, err = adapter.ReverseIterator([]byte("apple"), []byte("cherry"))
+	require.NoError(t, err)
+	defer iter.Close()
+
+	keys = nil
+	for iter.Valid() {
+		keys = append(keys, string(iter.Key()))
+		iter.Next()
+	}
+
+	// Should see keys from cherry (exclusive) down to apple (inclusive)
+	require.Equal(t, []string{"banana", "apple"}, keys)
+
+	// Test reverse iteration with wider range - should only see keys with "table1:" prefix in range
+	iter, err = adapter.ReverseIterator([]byte("apple"), []byte("zzz"))
+	require.NoError(t, err)
+	defer iter.Close()
+
+	keys = nil
+	for iter.Valid() {
+		keys = append(keys, string(iter.Key()))
+		iter.Next()
+	}
+
+	// Should see keys from cherry (exclusive) down to apple (inclusive)
+	require.Equal(t, []string{"cherry", "banana", "apple"}, keys)
+
+	// An adapter without key prefix should be able to iterate over all keys
+	adapter = AdaptBadger(db, []byte{})
+
+	iter, err = adapter.ReverseIterator(nil, nil)
+	require.NoError(t, err)
+	defer iter.Close()
+
+	keys = nil
+	for iter.Valid() {
+		keys = append(keys, string(iter.Key()))
+		iter.Next()
+	}
+
+	// Should see all keys in reverse order, regardless of prefix
+	require.Len(t, keys, 7)
+
+	iter, err = adapter.ReverseIterator([]byte("table2:date"), []byte("zebra"))
+	require.NoError(t, err)
+	defer iter.Close()
+
+	keys = nil
+	for iter.Valid() {
+		keys = append(keys, string(iter.Key()))
+		iter.Next()
+	}
+
+	require.Equal(t, []string{"table2:date"}, keys)
+
+	iter, err = adapter.ReverseIterator([]byte("table2:date"), []byte("zzz"))
+	require.NoError(t, err)
+	defer iter.Close()
+
+	keys = nil
+	for iter.Valid() {
+		keys = append(keys, string(iter.Key()))
+		iter.Next()
+	}
+
+	require.Equal(t, []string{"zebra", "table2:date"}, keys)
+}

go.mod

···
+module tangled.org/gbl08ma/didplcbft
+
+go 1.25.4
+
+require (
+	cosmossdk.io/core v0.12.1-0.20240725072823-6a2d039e1212
+	github.com/bluesky-social/indigo v0.0.0-20251009212240-20524de167fe
+	github.com/cometbft/cometbft v0.38.19
+	github.com/cosmos/iavl v1.3.5
+	github.com/cosmos/ics23/go v0.10.0
+	github.com/dgraph-io/badger/v4 v4.9.0
+	github.com/did-method-plc/go-didplc v0.0.0-20251125183445-342320c327e2
+	github.com/google/uuid v1.6.0
+	github.com/ipfs/go-cid v0.4.1
+	github.com/ipfs/go-ipld-cbor v0.1.0
+	github.com/klauspost/compress v1.18.0
+	github.com/palantir/stacktrace v0.0.0-20161112013806-78658fd2d177
+	github.com/polydawn/refmt v0.89.1-0.20221221234430-40501e09de1f
+	github.com/puzpuzpuz/xsync/v4 v4.2.0
+	github.com/rs/cors v1.11.1
+	github.com/samber/lo v1.52.0
+	github.com/samber/mo v1.16.0
+	github.com/spf13/viper v1.19.0
+	github.com/stretchr/testify v1.11.1
+	github.com/ucarion/urlpath v0.0.0-20200424170820-7ccc79b76bbb
+)
+
+require (
+	github.com/DataDog/zstd v1.4.5 // indirect
+	github.com/beorn7/perks v1.0.1 // indirect
+	github.com/cespare/xxhash/v2 v2.3.0 // indirect
+	github.com/cockroachdb/errors v1.11.3 // indirect
+	github.com/cockroachdb/fifo v0.0.0-20240606204812-0bbfbd93a7ce // indirect
+	github.com/cockroachdb/logtags v0.0.0-20230118201751-21c54148d20b // indirect
+	github.com/cockroachdb/pebble v1.1.5 // indirect
+	github.com/cockroachdb/redact v1.1.5 // indirect
+	github.com/cockroachdb/tokenbucket v0.0.0-20230807174530-cc333fc44b06 // indirect
+	github.com/cometbft/cometbft-db v0.14.1 // indirect
+	github.com/cosmos/gogoproto v1.7.0 // indirect
+	github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect
+	github.com/decred/dcrd/dcrec/secp256k1/v4 v4.4.0 // indirect
+	github.com/dgraph-io/ristretto/v2 v2.2.0 // indirect
+	github.com/dustin/go-humanize v1.0.1 // indirect
+	github.com/emicklei/dot v1.6.2 // indirect
+	github.com/fsnotify/fsnotify v1.7.0 // indirect
+	github.com/getsentry/sentry-go v0.27.0 // indirect
+	github.com/go-kit/kit v0.13.0 // indirect
+	github.com/go-kit/log v0.2.1 // indirect
+	github.com/go-logfmt/logfmt v0.6.0 // indirect
+	github.com/go-logr/logr v1.4.3 // indirect
+	github.com/go-logr/stdr v1.2.2 // indirect
+	github.com/gogo/protobuf v1.3.2 // indirect
+	github.com/golang/protobuf v1.5.4 // indirect
+	github.com/golang/snappy v0.0.4 // indirect
+	github.com/google/btree v1.1.3 // indirect
+	github.com/google/flatbuffers v25.2.10+incompatible // indirect
+	github.com/google/go-cmp v0.7.0 // indirect
+	github.com/google/orderedcode v0.0.1 // indirect
+	github.com/gorilla/websocket v1.5.3 // indirect
+	github.com/hashicorp/golang-lru/v2 v2.0.7 // indirect
+	github.com/hashicorp/hcl v1.0.0 // indirect
+	github.com/ipfs/go-block-format v0.2.0 // indirect
+	github.com/ipfs/go-ipfs-util v0.0.3 // indirect
+	github.com/ipfs/go-ipld-format v0.6.0 // indirect
+	github.com/jmhodges/levigo v1.0.0 // indirect
+	github.com/klauspost/cpuid/v2 v2.2.7 // indirect
+	github.com/kr/pretty v0.3.1 // indirect
+	github.com/kr/text v0.2.0 // indirect
+	github.com/lib/pq v1.10.9 // indirect
+	github.com/linxGnu/grocksdb v1.8.14 // indirect
+	github.com/magiconair/properties v1.8.7 // indirect
+	github.com/minio/highwayhash v1.0.3 // indirect
+	github.com/minio/sha256-simd v1.0.1 // indirect
+	github.com/mitchellh/mapstructure v1.5.0 // indirect
+	github.com/mr-tron/base58 v1.2.0 // indirect
+	github.com/multiformats/go-base32 v0.1.0 // indirect
+	github.com/multiformats/go-base36 v0.2.0 // indirect
+	github.com/multiformats/go-multibase v0.2.0 // indirect
+	github.com/multiformats/go-multihash v0.2.3 // indirect
+	github.com/multiformats/go-varint v0.0.7 // indirect
+	github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirect
+	github.com/oasisprotocol/curve25519-voi v0.0.0-20220708102147-0a8a51822cae // indirect
+	github.com/pelletier/go-toml/v2 v2.2.2 // indirect
+	github.com/petermattis/goid v0.0.0-20240813172612-4fcff4a6cae7 // indirect
+	github.com/pkg/errors v0.9.1 // indirect
+	github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect
+	github.com/prometheus/client_golang v1.21.0 // indirect
+	github.com/prometheus/client_model v0.6.1 // indirect
+	github.com/prometheus/common v0.62.0 // indirect
+	github.com/prometheus/procfs v0.15.1 // indirect
+	github.com/rcrowley/go-metrics v0.0.0-20201227073835-cf1acfcdf475 // indirect
+	github.com/rogpeppe/go-internal v1.13.1 // indirect
+	github.com/sagikazarmark/locafero v0.4.0 // indirect
+	github.com/sagikazarmark/slog-shim v0.1.0 // indirect
+	github.com/sasha-s/go-deadlock v0.3.5 // indirect
+	github.com/sourcegraph/conc v0.3.0 // indirect
+	github.com/spaolacci/murmur3 v1.1.0 // indirect
+	github.com/spf13/afero v1.11.0 // indirect
+	github.com/spf13/cast v1.8.0 // indirect
+	github.com/spf13/pflag v1.0.6 // indirect
+	github.com/subosito/gotenv v1.6.0 // indirect
+	github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7 // indirect
+	github.com/whyrusleeping/cbor-gen v0.2.1-0.20241030202151-b7a6831be65e // indirect
+	gitlab.com/yawning/secp256k1-voi v0.0.0-20230925100816-f2616030848b // indirect
+	gitlab.com/yawning/tuplehash v0.0.0-20230713102510-df83abbf9a02 // indirect
+	go.etcd.io/bbolt v1.4.0-alpha.0.0.20240404170359-43604f3112c5 // indirect
+	go.opentelemetry.io/auto/sdk v1.1.0 // indirect
+	go.opentelemetry.io/otel v1.37.0 // indirect
+	go.opentelemetry.io/otel/metric v1.37.0 // indirect
+	go.opentelemetry.io/otel/trace v1.37.0 // indirect
+	go.uber.org/multierr v1.11.0 // indirect
+	golang.org/x/crypto v0.41.0 // indirect
+	golang.org/x/exp v0.0.0-20250620022241-b7579e27df2b // indirect
+	golang.org/x/net v0.43.0 // indirect
+	golang.org/x/sync v0.16.0 // indirect
+	golang.org/x/sys v0.36.0 // indirect
+	golang.org/x/text v0.28.0 // indirect
+	golang.org/x/tools v0.36.0 // indirect
+	golang.org/x/xerrors v0.0.0-20231012003039-104605ab7028 // indirect
+	google.golang.org/genproto/googleapis/rpc v0.0.0-20241202173237-19429a94021a // indirect
+	google.golang.org/grpc v1.70.0 // indirect
+	google.golang.org/protobuf v1.36.7 // indirect
+	gopkg.in/ini.v1 v1.67.0 // indirect
+	gopkg.in/yaml.v3 v3.0.1 // indirect
+	lukechampine.com/blake3 v1.2.1 // indirect
+)
+
+replace github.com/palantir/stacktrace v0.0.0-20161112013806-78658fd2d177 => github.com/gsgalloway/stacktrace v0.0.0-20200507040314-ca3802f754c7

go.sum

···
+cosmossdk.io/core v0.12.1-0.20240725072823-6a2d039e1212 h1:yLjl2aq6XMa5Zb1aKfwNHn1U+fFmmAtZyWKNWm/yVH8=
+cosmossdk.io/core v0.12.1-0.20240725072823-6a2d039e1212/go.mod h1:sLzMwAW9HW+Nm3GltUVHDRSRZbcXLy9+2AYgi2bwt/s=
+github.com/Azure/go-ansiterm v0.0.0-20230124172434-306776ec8161 h1:L/gRVlceqvL25UVaW/CKtUDjefjrs0SPonmDGUVOYP0=
+github.com/Azure/go-ansiterm v0.0.0-20230124172434-306776ec8161/go.mod h1:xomTg63KZ2rFqZQzSB4Vz2SUXa1BpHTVz9L5PTmPC4E=
+github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
+github.com/DataDog/zstd v1.4.5 h1:EndNeuB0l9syBZhut0wns3gV1hL8zX8LIu6ZiVHWLIQ=
+github.com/DataDog/zstd v1.4.5/go.mod h1:1jcaCB/ufaK+sKp1NBhlGmpz41jOoPQ35bpF36t7BBo=
+github.com/Microsoft/go-winio v0.6.1 h1:9/kr64B9VUZrLm5YYwbGtUJnMgqWVOdUAXu6Migciow=
+github.com/Microsoft/go-winio v0.6.1/go.mod h1:LRdKpFKfdobln8UmuiYcKPot9D2v6svN5+sAH+4kjUM=
+github.com/Nvveen/Gotty v0.0.0-20120604004816-cd527374f1e5 h1:TngWCqHvy9oXAN6lEVMRuU21PR1EtLVZJmdB18Gu3Rw=
+github.com/Nvveen/Gotty v0.0.0-20120604004816-cd527374f1e5/go.mod h1:lmUJ/7eu/Q8D7ML55dXQrVaamCz2vxCfdQBasLZfHKk=
+github.com/VividCortex/gohistogram v1.0.0 h1:6+hBz+qvs0JOrrNhhmR7lFxo5sINxBCGXrdtl/UvroE=
+github.com/VividCortex/gohistogram v1.0.0/go.mod h1:Pf5mBqqDxYaXu3hDrrU+w6nw50o/4+TcAqDqk/vUH7g=
+github.com/adlio/schema v1.3.6 h1:k1/zc2jNfeiZBA5aFTRy37jlBIuCkXCm0XmvpzCKI9I=
+github.com/adlio/schema v1.3.6/go.mod h1:qkxwLgPBd1FgLRHYVCmQT/rrBr3JH38J9LjmVzWNudg=
+github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM=
+github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw=
+github.com/bluesky-social/indigo v0.0.0-20251009212240-20524de167fe h1:VBhaqE5ewQgXbY5SfSWFZC/AwHFo7cHxZKFYi2ce9Yo=
+github.com/bluesky-social/indigo v0.0.0-20251009212240-20524de167fe/go.mod h1:RuQVrCGm42QNsgumKaR6se+XkFKfCPNwdCiTvqKRUck=
+github.com/btcsuite/btcd/btcutil v1.1.6 h1:zFL2+c3Lb9gEgqKNzowKUPQNb8jV7v5Oaodi/AYFd6c=
+github.com/btcsuite/btcd/btcutil v1.1.6/go.mod h1:9dFymx8HpuLqBnsPELrImQeTQfKBQqzqGbbV3jK55aE=
+github.com/cenkalti/backoff v2.2.1+incompatible h1:tNowT99t7UNflLxfYYSlKYsBpXdEet03Pg2g16Swow4=
+github.com/cenkalti/backoff v2.2.1+incompatible/go.mod h1:90ReRw6GdpyfrHakVjL/QHaoyV4aDUVVkXQJJJ3NXXM=
+github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs=
+github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
+github.com/cockroachdb/datadriven v1.0.3-0.20230413201302-be42291fc80f h1:otljaYPt5hWxV3MUfO5dFPFiOXg9CyG5/kCfayTqsJ4=
+github.com/cockroachdb/datadriven v1.0.3-0.20230413201302-be42291fc80f/go.mod h1:a9RdTaap04u637JoCzcUoIcDmvwSUtcUFtT/C3kJlTU=
+github.com/cockroachdb/errors v1.11.3 h1:5bA+k2Y6r+oz/6Z/RFlNeVCesGARKuC6YymtcDrbC/I=
+github.com/cockroachdb/errors v1.11.3/go.mod h1:m4UIW4CDjx+R5cybPsNrRbreomiFqt8o1h1wUVazSd8=
+github.com/cockroachdb/fifo v0.0.0-20240606204812-0bbfbd93a7ce h1:giXvy4KSc/6g/esnpM7Geqxka4WSqI1SZc7sMJFd3y4=
+github.com/cockroachdb/fifo v0.0.0-20240606204812-0bbfbd93a7ce/go.mod h1:9/y3cnZ5GKakj/H4y9r9GTjCvAFta7KLgSHPJJYc52M=
+github.com/cockroachdb/logtags v0.0.0-20230118201751-21c54148d20b h1:r6VH0faHjZeQy818SGhaone5OnYfxFR/+AzdY3sf5aE=
+github.com/cockroachdb/logtags v0.0.0-20230118201751-21c54148d20b/go.mod h1:Vz9DsVWQQhf3vs21MhPMZpMGSht7O/2vFW2xusFUVOs=
+github.com/cockroachdb/pebble v1.1.5 h1:5AAWCBWbat0uE0blr8qzufZP5tBjkRyy/jWe1QWLnvw=
+github.com/cockroachdb/pebble v1.1.5/go.mod h1:17wO9el1YEigxkP/YtV8NtCivQDgoCyBg5c4VR/eOWo=
+github.com/cockroachdb/redact v1.1.5 h1:u1PMllDkdFfPWaNGMyLD1+so+aq3uUItthCFqzwPJ30=
+github.com/cockroachdb/redact v1.1.5/go.mod h1:BVNblN9mBWFyMyqK1k3AAiSxhvhfK2oOZZ2lK+dpvRg=
+github.com/cockroachdb/tokenbucket v0.0.0-20230807174530-cc333fc44b06 h1:zuQyyAKVxetITBuuhv3BI9cMrmStnpT18zmgmTxunpo=
+github.com/cockroachdb/tokenbucket v0.0.0-20230807174530-cc333fc44b06/go.mod h1:7nc4anLGjupUW/PeY5qiNYsdNXj7zopG+eqsS7To5IQ=
+github.com/cometbft/cometbft v0.38.19 h1:vNdtCkvhuwUlrcLPAyigV7lQpmmo+tAq8CsB8gZjEYw=
+github.com/cometbft/cometbft v0.38.19/go.mod h1:UCu8dlHqvkAsmAFmWDRWNZJPlu6ya2fTWZlDrWsivwo=
+github.com/cometbft/cometbft-db v0.14.1 h1:SxoamPghqICBAIcGpleHbmoPqy+crij/++eZz3DlerQ=
+github.com/cometbft/cometbft-db v0.14.1/go.mod h1:KHP1YghilyGV/xjD5DP3+2hyigWx0WTp9X+0Gnx0RxQ=
+github.com/containerd/continuity v0.3.0 h1:nisirsYROK15TAMVukJOUyGJjz4BNQJBVsNvAXZJ/eg=
+github.com/containerd/continuity v0.3.0/go.mod h1:wJEAIwKOm/pBZuBd0JmeTvnLquTB1Ag8espWhkykbPM=
+github.com/cosmos/gogoproto v1.7.0 h1:79USr0oyXAbxg3rspGh/m4SWNyoz/GLaAh0QlCe2fro=
+github.com/cosmos/gogoproto v1.7.0/go.mod h1:yWChEv5IUEYURQasfyBW5ffkMHR/90hiHgbNgrtp4j0=
+github.com/cosmos/iavl v1.3.5 h1:wTDFbaa/L0FVUrwTlzMnjN3fphtKgWxgcZmTc45MZuA=
+github.com/cosmos/iavl v1.3.5/go.mod h1:T6SfBcyhulVIY2G/ZtAtQm/QiJvsuhIos52V4dWYk88=
+github.com/cosmos/ics23/go v0.10.0 h1:iXqLLgp2Lp+EdpIuwXTYIQU+AiHj9mOC2X9ab++bZDM=
+github.com/cosmos/ics23/go v0.10.0/go.mod h1:ZfJSmng/TBNTBkFemHHHj5YY7VAU/MBU980F4VU1NG0=
+github.com/cpuguy83/go-md2man/v2 v2.0.0-20190314233015-f79a8a8ca69d/go.mod h1:maD7wRr/U5Z6m/iR4s+kqSMx2CaBsrgA7czyZG/E6dU=
+github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM=
+github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/decred/dcrd/crypto/blake256 v1.1.0 h1:zPMNGQCm0g4QTY27fOCorQW7EryeQ/U0x++OzVrdms8=
+github.com/decred/dcrd/crypto/blake256 v1.1.0/go.mod h1:2OfgNZ5wDpcsFmHmCK5gZTPcCXqlm2ArzUIkw9czNJo=
+github.com/decred/dcrd/dcrec/secp256k1/v4 v4.4.0 h1:NMZiJj8QnKe1LgsbDayM4UoHwbvwDRwnI3hwNaAHRnc=
+github.com/decred/dcrd/dcrec/secp256k1/v4 v4.4.0/go.mod h1:ZXNYxsqcloTdSy/rNShjYzMhyjf0LaoftYK0p+A3h40=
+github.com/dgraph-io/badger/v4 v4.9.0 h1:tpqWb0NewSrCYqTvywbcXOhQdWcqephkVkbBmaaqHzc=
+github.com/dgraph-io/badger/v4 v4.9.0/go.mod h1:5/MEx97uzdPUHR4KtkNt8asfI2T4JiEiQlV7kWUo8c0=
+github.com/dgraph-io/ristretto/v2 v2.2.0 h1:bkY3XzJcXoMuELV8F+vS8kzNgicwQFAaGINAEJdWGOM=
+github.com/dgraph-io/ristretto/v2 v2.2.0/go.mod h1:RZrm63UmcBAaYWC1DotLYBmTvgkrs0+XhBd7Npn7/zI=
+github.com/dgryski/go-farm v0.0.0-20240924180020-3414d57e47da h1:aIftn67I1fkbMa512G+w+Pxci9hJPB8oMnkcP3iZF38=
+github.com/dgryski/go-farm v0.0.0-20240924180020-3414d57e47da/go.mod h1:SqUrOPUnsFjfmXRMNPybcSiG0BgUW2AuFH8PAnS2iTw=
+github.com/did-method-plc/go-didplc v0.0.0-20251125183445-342320c327e2 h1:ofb700k/ZtxvDoh+rLdO2BHbFa2KWKATlKoaEQ45GYI=
+github.com/did-method-plc/go-didplc v0.0.0-20251125183445-342320c327e2/go.mod h1:KriMp3m/YfciVcyUoQdXr5klXHEasvPr4yQurhTSJr4=
+github.com/docker/go-connections v0.4.0 h1:El9xVISelRB7BuFusrZozjnkIM5YnzCViNKohAFqRJQ=
+github.com/docker/go-connections v0.4.0/go.mod h1:Gbd7IOopHjR8Iph03tsViu4nIes5XhDvyHbTtUxmeec=
+github.com/docker/go-units v0.5.0 h1:69rxXcBk27SvSaaxTtLh/8llcHD8vYHT7WSdRZ/jvr4=
+github.com/docker/go-units v0.5.0/go.mod h1:fgPhTUdO+D/Jk86RDLlptpiXQzgHJF7gydDDbaIK4Dk=
+github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY=
+github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto=
+github.com/emicklei/dot v1.6.2 h1:08GN+DD79cy/tzN6uLCT84+2Wk9u+wvqP+Hkx/dIR8A=
+github.com/emicklei/dot v1.6.2/go.mod h1:DeV7GvQtIw4h2u73RKBkkFdvVAz0D9fzeJrgPW6gy/s=
+github.com/fortytw2/leaktest v1.3.0 h1:u8491cBMTQ8ft8aeV+adlcytMZylmA5nnwwkRZjI8vw=
+github.com/fortytw2/leaktest v1.3.0/go.mod h1:jDsjWgpAGjm2CA7WthBh/CdZYEPF31XHquHwclZch5g=
+github.com/frankban/quicktest v1.14.6 h1:7Xjx+VpznH+oBnejlPUj8oUpdxnVs4f8XU8WnHkI4W8=
+github.com/frankban/quicktest v1.14.6/go.mod h1:4ptaffx2x8+WTWXmUCuVU6aPUX1/Mz7zb5vbUoiM6w0=
+github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
+github.com/fsnotify/fsnotify v1.4.9/go.mod h1:znqG4EE+3YCdAaPaxE2ZRY/06pZUdp0tY4IgpuI1SZQ=
+github.com/fsnotify/fsnotify v1.7.0 h1:8JEhPFa5W2WU7YfeZzPNqzMP6Lwt7L2715Ggo0nosvA=
+github.com/fsnotify/fsnotify v1.7.0/go.mod h1:40Bi/Hjc2AVfZrqy+aj+yEI+/bRxZnMJyTJwOpGvigM=
+github.com/getsentry/sentry-go v0.27.0 h1:Pv98CIbtB3LkMWmXi4Joa5OOcwbmnX88sF5qbK3r3Ps=
+github.com/getsentry/sentry-go v0.27.0/go.mod h1:lc76E2QywIyW8WuBnwl8Lc4bkmQH4+w1gwTf25trprY=
+github.com/go-errors/errors v1.4.2 h1:J6MZopCL4uSllY1OfXM374weqZFFItUbrImctkmUxIA=
+github.com/go-errors/errors v1.4.2/go.mod h1:sIVyrIiJhuEF+Pj9Ebtd6P/rEYROXFi3BopGUQ5a5Og=
+github.com/go-kit/kit v0.13.0 h1:OoneCcHKHQ03LfBpoQCUfCluwd2Vt3ohz+kvbJneZAU=
+github.com/go-kit/kit v0.13.0/go.mod h1:phqEHMMUbyrCFCTgH48JueqrM3md2HcAZ8N3XE4FKDg=
+github.com/go-kit/log v0.2.1 h1:MRVx0/zhvdseW+Gza6N9rVzU/IVzaeE1SFI4raAhmBU=
+github.com/go-kit/log v0.2.1/go.mod h1:NwTd00d/i8cPZ3xOwwiv2PO5MOcx78fFErGNcVmBjv0=
+github.com/go-logfmt/logfmt v0.6.0 h1:wGYYu3uicYdqXVgoYbvnkrPVXkuLM1p1ifugDMEdRi4=
+github.com/go-logfmt/logfmt v0.6.0/go.mod h1:WYhtIu8zTZfxdn5+rREduYbwxfcBr/Vr6KEVveWlfTs=
+github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A=
+github.com/go-logr/logr v1.4.3 h1:CjnDlHq8ikf6E492q6eKboGOC0T8CDaOvkHCIg8idEI=
+github.com/go-logr/logr v1.4.3/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
+github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag=
+github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE=
+github.com/go-yaml/yaml v2.1.0+incompatible/go.mod h1:w2MrLa16VYP0jy6N7M5kHaCkaLENm+P+Tv+MfurjSw0=
+github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q=
+github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q=
+github.com/golang/mock v1.6.0 h1:ErTB+efbowRARo13NNdxyJji2egdxLGQhRaY+DUumQc=
+github.com/golang/mock v1.6.0/go.mod h1:p6yTPP+5HYm5mzsMV8JkE6ZKdX+/wYM6Hr+LicevLPs=
+github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+github.com/golang/protobuf v1.4.0-rc.1/go.mod h1:ceaxUfeHdC40wWswd/P6IGgMaK3YpKi5j83Wpe3EHw8=
+github.com/golang/protobuf v1.4.0-rc.1.0.20200221234624-67d41d38c208/go.mod h1:xKAWHe0F5eneWXFV3EuXVDTCmh+JuBKY0li0aMyXATA=
+github.com/golang/protobuf v1.4.0-rc.2/go.mod h1:LlEzMj4AhA7rCAGe4KMBDvJI+AwstrUpVNzEA03Pprs=
+github.com/golang/protobuf v1.4.0-rc.4.0.20200313231945-b860323f09d0/go.mod h1:WU3c8KckQ9AFe+yFwt9sWVRKCVIyN9cPHBJSNnbL67w=
+github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvqG2KuDX0=
+github.com/golang/protobuf v1.4.2/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
+github.com/golang/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek=
+github.com/golang/protobuf v1.5.4/go.mod h1:lnTiLA8Wa4RWRcIUkrtSVa5nRhsEGBg48fD6rSs7xps=
+github.com/golang/snappy v0.0.4 h1:yAGX7huGHXlcLOEtBnF4w7FQwA26wojNCwOYAEhLjQM=
+github.com/golang/snappy v0.0.4/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
+github.com/google/btree v1.1.3 h1:CVpQJjYgC4VbzxeGVHfvZrv1ctoYCAI8vbl07Fcxlyg=
+github.com/google/btree v1.1.3/go.mod h1:qOPhT0dTNdNzV6Z/lhRX0YXUafgPLFUh+gZMl761Gm4=
+github.com/google/flatbuffers v25.2.10+incompatible h1:F3vclr7C3HpB1k9mxCGRMXq6FdUalZ6H/pNX4FP1v0Q=
+github.com/google/flatbuffers v25.2.10+incompatible/go.mod h1:1AeVuKshWv4vARoZatz6mlQ0JxURH0Kv5+zNeJKJCa8=
+github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
+github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
+github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
+github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
+github.com/google/orderedcode v0.0.1 h1:UzfcAexk9Vhv8+9pNOgRu41f16lHq725vPwnSeiG/Us=
+github.com/google/orderedcode v0.0.1/go.mod h1:iVyU4/qPKHY5h/wSd6rZZCDcLJNxiWO6dvsYES2Sb20=
+github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
+github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/gopherjs/gopherjs v0.0.0-20181017120253-0766667cb4d1 h1:EGx4pi6eqNxGaHF6qqu48+N2wcFQ5qg5FXgOdqsJ5d8=
+github.com/gopherjs/gopherjs v0.0.0-20181017120253-0766667cb4d1/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY=
+github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aNNg=
+github.com/gorilla/websocket v1.5.3/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
+github.com/gsgalloway/stacktrace v0.0.0-20200507040314-ca3802f754c7 h1:hEyBOiA4Zv1nIstYO3VU4p/t/m5ikHZWnyQOgteoc+E=
+github.com/gsgalloway/stacktrace v0.0.0-20200507040314-ca3802f754c7/go.mod h1:AWPtRYnH+Coi03yskhmgZHPcZrv89PoxagXJr1TsFyc=
+github.com/hashicorp/golang-lru/v2 v2.0.7 h1:a+bsQ5rvGLjzHuww6tVxozPZFVghXaHOwFs4luLUK2k=
+github.com/hashicorp/golang-lru/v2 v2.0.7/go.mod h1:QeFd9opnmA6QUJc5vARoKUSoFhyfM2/ZepoAG6RGpeM=
+github.com/hashicorp/hcl v1.0.0 h1:0Anlzjpi4vEasTeNFn2mLJgTSwt0+6sfsiTG8qcWGx4=
+github.com/hashicorp/hcl v1.0.0/go.mod h1:E5yfLk+7swimpb2L/Alb/PJmXilQ/rhwaUYs4T20WEQ=
+github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU=
+github.com/ipfs/go-block-format v0.2.0 h1:ZqrkxBA2ICbDRbK8KJs/u0O3dlp6gmAuuXUJNiW1Ycs=
+github.com/ipfs/go-block-format v0.2.0/go.mod h1:+jpL11nFx5A/SPpsoBn6Bzkra/zaArfSmsknbPMYgzM=
+github.com/ipfs/go-cid v0.4.1 h1:A/T3qGvxi4kpKWWcPC/PgbvDA2bjVLO7n4UeVwnbs/s=
+github.com/ipfs/go-cid v0.4.1/go.mod h1:uQHwDeX4c6CtyrFwdqyhpNcxVewur1M7l7fNU7LKwZk=
+github.com/ipfs/go-ipfs-util v0.0.3 h1:2RFdGez6bu2ZlZdI+rWfIdbQb1KudQp3VGwPtdNCmE0=
+github.com/ipfs/go-ipfs-util v0.0.3/go.mod h1:LHzG1a0Ig4G+iZ26UUOMjHd+lfM84LZCrn17xAKWBvs=
+github.com/ipfs/go-ipld-cbor v0.1.0 h1:dx0nS0kILVivGhfWuB6dUpMa/LAwElHPw1yOGYopoYs=
+github.com/ipfs/go-ipld-cbor v0.1.0/go.mod h1:U2aYlmVrJr2wsUBU67K4KgepApSZddGRDWBYR0H4sCk=
+github.com/ipfs/go-ipld-format v0.6.0 h1:VEJlA2kQ3LqFSIm5Vu6eIlSxD/Ze90xtc4Meten1F5U=
+github.com/ipfs/go-ipld-format v0.6.0/go.mod h1:g4QVMTn3marU3qXchwjpKPKgJv+zF+OlaKMyhJ4LHPg=
+github.com/jmhodges/levigo v1.0.0 h1:q5EC36kV79HWeTBWsod3mG11EgStG3qArTKcvlksN1U=
+github.com/jmhodges/levigo v1.0.0/go.mod h1:Q6Qx+uH3RAqyK4rFQroq9RL7mdkABMcfhEI+nNuzMJQ=
+github.com/jtolds/gls v4.20.0+incompatible h1:xdiiI2gbIgH/gLH7ADydsJ1uDOEzR8yvV7C0MuV77Wo=
+github.com/jtolds/gls v4.20.0+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU=
+github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8=
+github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
+github.com/klauspost/compress v1.18.0 h1:c/Cqfb0r+Yi+JtIEq73FWXVkRonBlf0CRNYc8Zttxdo=
+github.com/klauspost/compress v1.18.0/go.mod h1:2Pp+KzxcywXVXMr50+X0Q/Lsb43OQHYWRCY2AiWywWQ=
+github.com/klauspost/cpuid/v2 v2.2.7 h1:ZWSB3igEs+d0qvnxR/ZBzXVmxkgt8DdzP6m9pfuVLDM=
+github.com/klauspost/cpuid/v2 v2.2.7/go.mod h1:Lcz8mBdAVJIBVzewtcLocK12l3Y+JytZYpaMropDUws=
+github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
+github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
+github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
+github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
+github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc=
+github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw=
+github.com/lib/pq v1.10.9 h1:YXG7RB+JIjhP29X+OtkiDnYaXQwpS4JEWq7dtCCRUEw=
+github.com/lib/pq v1.10.9/go.mod h1:AlVN5x4E4T544tWzH6hKfbfQvm3HdbOxrmggDNAPY9o=
+github.com/linxGnu/grocksdb v1.8.14 h1:HTgyYalNwBSG/1qCQUIott44wU5b2Y9Kr3z7SK5OfGQ=
+github.com/linxGnu/grocksdb v1.8.14/go.mod h1:QYiYypR2d4v63Wj1adOOfzglnoII0gLj3PNh4fZkcFA=
+github.com/magiconair/properties v1.8.7 h1:IeQXZAiQcpL9mgcAe1Nu6cX9LLw6ExEHKjN0VQdvPDY=
+github.com/magiconair/properties v1.8.7/go.mod h1:Dhd985XPs7jluiymwWYZ0G4Z61jb3vdS329zhj2hYo0=
+github.com/minio/highwayhash v1.0.3 h1:kbnuUMoHYyVl7szWjSxJnxw11k2U709jqFPPmIUyD6Q=
+github.com/minio/highwayhash v1.0.3/go.mod h1:GGYsuwP/fPD6Y9hMiXuapVvlIUEhFhMTh0rxU3ik1LQ=
+github.com/minio/sha256-simd v1.0.1 h1:6kaan5IFmwTNynnKKpDHe6FWHohJOHhCPchzK49dzMM=
+github.com/minio/sha256-simd v1.0.1/go.mod h1:Pz6AKMiUdngCLpeTL/RJY1M9rUuPMYujV5xJjtbRSN8=
+github.com/mitchellh/mapstructure v1.5.0 h1:jeMsZIYE/09sWLaz43PL7Gy6RuMjD2eJVyuac5Z2hdY=
+github.com/mitchellh/mapstructure v1.5.0/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo=
+github.com/mr-tron/base58 v1.2.0 h1:T/HDJBh4ZCPbU39/+c3rRvE0uKBQlU27+QI8LJ4t64o=
+github.com/mr-tron/base58 v1.2.0/go.mod h1:BinMc/sQntlIE1frQmRFPUoPA1Zkr8VRgBdjWI2mNwc=
+github.com/multiformats/go-base32 v0.1.0 h1:pVx9xoSPqEIQG8o+UbAe7DNi51oej1NtK+aGkbLYxPE=
+github.com/multiformats/go-base32 v0.1.0/go.mod h1:Kj3tFY6zNr+ABYMqeUNeGvkIC/UYgtWibDcT0rExnbI=
+github.com/multiformats/go-base36 v0.2.0 h1:lFsAbNOGeKtuKozrtBsAkSVhv1p9D0/qedU9rQyccr0=
+github.com/multiformats/go-base36 v0.2.0/go.mod h1:qvnKE++v+2MWCfePClUEjE78Z7P2a1UV0xHgWc0hkp4=
+github.com/multiformats/go-multibase v0.2.0 h1:isdYCVLvksgWlMW9OZRYJEa9pZETFivncJHmHnnd87g=
+github.com/multiformats/go-multibase v0.2.0/go.mod h1:bFBZX4lKCA/2lyOFSAoKH5SS6oPyjtnzK/XTFDPkNuk=
+github.com/multiformats/go-multihash v0.2.3 h1:7Lyc8XfX/IY2jWb/gI7JP+o7JEq9hOa7BFvVU9RSh+U=
+github.com/multiformats/go-multihash v0.2.3/go.mod h1:dXgKXCXjBzdscBLk9JkjINiEsCKRVch90MdaGiKsvSM=
+github.com/multiformats/go-varint v0.0.7 h1:sWSGR+f/eu5ABZA2ZpYKBILXTTs9JWpdEM/nEGOHFS8=
+github.com/multiformats/go-varint v0.0.7/go.mod h1:r8PUYw/fD/SjBCiKOoDlGF6QawOELpZAu9eioSos/OU=
+github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 h1:C3w9PqII01/Oq1c1nUAm88MOHcQC9l5mIlSMApZMrHA=
+github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ=
+github.com/nxadm/tail v1.4.4 h1:DQuhQpB1tVlglWS2hLQ5OV6B5r8aGxSrPc5Qo6uTN78=
+github.com/nxadm/tail v1.4.4/go.mod h1:kenIhsEOeOJmVchQTgglprH7qJGnHDVpk1VPCcaMI8A=
+github.com/oasisprotocol/curve25519-voi v0.0.0-20220708102147-0a8a51822cae h1:FatpGJD2jmJfhZiFDElaC0QhZUDQnxUeAwTGkfAHN3I=
+github.com/oasisprotocol/curve25519-voi v0.0.0-20220708102147-0a8a51822cae/go.mod h1:hVoHR2EVESiICEMbg137etN/Lx+lSrHPTD39Z/uE+2s=
+github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
+github.com/onsi/ginkgo v1.12.1/go.mod h1:zj2OWP4+oCPe1qIXoGWkgMRwljMUYCdkwsT2108oapk=
+github.com/onsi/ginkgo v1.14.0 h1:2mOpI4JVVPBN+WQRa0WKH2eXR+Ey+uK4n7Zj0aYpIQA=
+github.com/onsi/ginkgo v1.14.0/go.mod h1:iSB4RoI2tjJc9BBv4NKIKWKya62Rps+oPG/Lv9klQyY=
+github.com/onsi/gomega v1.7.1/go.mod h1:XdKZgCCFLUoM/7CFJVPcG8C1xQ1AJ0vpAezJrB7JYyY=
+github.com/onsi/gomega v1.10.1/go.mod h1:iN09h71vgCQne3DLsj+A5owkum+a2tYe+TOCB1ybHNo=
+github.com/onsi/gomega v1.26.0 h1:03cDLK28U6hWvCAns6NeydX3zIm4SF3ci69ulidS32Q=
+github.com/onsi/gomega v1.26.0/go.mod h1:r+zV744Re+DiYCIPRlYOTxn0YkOLcAnW8k1xXdMPGhM=
+github.com/opencontainers/go-digest v1.0.0 h1:apOUWs51W5PlhuyGyz9FCeeBIOUDA/6nW8Oi/yOhh5U=
+github.com/opencontainers/go-digest v1.0.0/go.mod h1:0JzlMkj0TRzQZfJkVvzbP0HBR3IKzErnv2BNG4W4MAM=
+github.com/opencontainers/image-spec v1.1.0-rc2 h1:2zx/Stx4Wc5pIPDvIxHXvXtQFW/7XWJGmnM7r3wg034=
+github.com/opencontainers/image-spec v1.1.0-rc2/go.mod h1:3OVijpioIKYWTqjiG0zfF6wvoJ4fAXGbjdZuI2NgsRQ=
+github.com/opencontainers/runc v1.1.12 h1:BOIssBaW1La0/qbNZHXOOa71dZfZEQOzW7dqQf3phss=
+github.com/opencontainers/runc v1.1.12/go.mod h1:S+lQwSfncpBha7XTy/5lBwWgm5+y5Ma/O44Ekby9FK8=
+github.com/ory/dockertest v3.3.5+incompatible h1:iLLK6SQwIhcbrG783Dghaaa3WPzGc+4Emza6EbVUUGA=
+github.com/ory/dockertest v3.3.5+incompatible/go.mod h1:1vX4m9wsvi00u5bseYwXaSnhNrne+V0E6LAcBILJdPs=
+github.com/pelletier/go-toml/v2 v2.2.2 h1:aYUidT7k73Pcl9nb2gScu7NSrKCSHIDE89b3+6Wq+LM=
+github.com/pelletier/go-toml/v2 v2.2.2/go.mod h1:1t835xjRzz80PqgE6HHgN2JOsmgYu/h4qDAS4n929Rs=
+github.com/petermattis/goid v0.0.0-20240813172612-4fcff4a6cae7 h1:Dx7Ovyv/SFnMFw3fD4oEoeorXc6saIiQ23LrGLth0Gw=
+github.com/petermattis/goid v0.0.0-20240813172612-4fcff4a6cae7/go.mod h1:pxMtw7cyUw6B2bRH0ZBANSPg+AoSud1I1iyJHI69jH4=
+github.com/pingcap/errors v0.11.4 h1:lFuQV/oaUMGcD2tqt+01ROSmJs75VG1ToEOkZIZ4nE4=
+github.com/pingcap/errors v0.11.4/go.mod h1:Oi8TUi2kEtXXLMJk9l1cGmz20kV3TaQ0usTwv5KuLY8=
+github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA=
+github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
+github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U=
+github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/polydawn/refmt v0.89.1-0.20221221234430-40501e09de1f h1:VXTQfuJj9vKR4TCkEuWIckKvdHFeJH/huIFJ9/cXOB0=
+github.com/polydawn/refmt v0.89.1-0.20221221234430-40501e09de1f/go.mod h1:/zvteZs/GwLtCgZ4BL6CBsk9IKIlexP43ObX9AxTqTw=
+github.com/prometheus/client_golang v1.21.0 h1:DIsaGmiaBkSangBgMtWdNfxbMNdku5IK6iNhrEqWvdA=
+github.com/prometheus/client_golang v1.21.0/go.mod h1:U9NM32ykUErtVBxdvD3zfi+EuFkkaBvMb09mIfe0Zgg=
+github.com/prometheus/client_model v0.6.1 h1:ZKSh/rekM+n3CeS952MLRAdFwIKqeY8b62p8ais2e9E=
+github.com/prometheus/client_model v0.6.1/go.mod h1:OrxVMOVHjw3lKMa8+x6HeMGkHMQyHDk9E3jmP2AmGiY=
+github.com/prometheus/common v0.62.0 h1:xasJaQlnWAeyHdUBeGjXmutelfJHWMRr+Fg4QszZ2Io=
+github.com/prometheus/common v0.62.0/go.mod h1:vyBcEuLSvWos9B1+CyL7JZ2up+uFzXhkqml0W5zIY1I=
+github.com/prometheus/procfs v0.15.1 h1:YagwOFzUgYfKKHX6Dr+sHT7km/hxC76UB0learggepc=
+github.com/prometheus/procfs v0.15.1/go.mod h1:fB45yRUv8NstnjriLhBQLuOUt+WW4BsoGhij/e3PBqk=
+github.com/puzpuzpuz/xsync/v4 v4.2.0 h1:dlxm77dZj2c3rxq0/XNvvUKISAmovoXF4a4qM6Wvkr0=
+github.com/puzpuzpuz/xsync/v4 v4.2.0/go.mod h1:VJDmTCJMBt8igNxnkQd86r+8KUeN1quSfNKu5bLYFQo=
+github.com/rcrowley/go-metrics v0.0.0-20201227073835-cf1acfcdf475 h1:N/ElC8H3+5XpJzTSTfLsJV/mx9Q9g7kxmchpfZyxgzM=
+github.com/rcrowley/go-metrics v0.0.0-20201227073835-cf1acfcdf475/go.mod h1:bCqnVzQkZxMG4s8nGwiZ5l3QUCyqpo9Y+/ZMZ9VjZe4=
+github.com/rogpeppe/go-internal v1.9.0/go.mod h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs=
+github.com/rogpeppe/go-internal v1.13.1 h1:KvO1DLK/DRN07sQ1LQKScxyZJuNnedQ5/wKSR38lUII=
+github.com/rogpeppe/go-internal v1.13.1/go.mod h1:uMEvuHeurkdAXX61udpOXGD/AzZDWNMNyH2VO9fmH0o=
+github.com/rs/cors v1.11.1 h1:eU3gRzXLRK57F5rKMGMZURNdIG4EoAmX8k94r9wXWHA=
+github.com/rs/cors v1.11.1/go.mod h1:XyqrcTp5zjWr1wsJ8PIRZssZ8b/WMcMf71DJnit4EMU=
+github.com/russross/blackfriday/v2 v2.0.1/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
+github.com/sagikazarmark/locafero v0.4.0 h1:HApY1R9zGo4DBgr7dqsTH/JJxLTTsOt7u6keLGt6kNQ=
+github.com/sagikazarmark/locafero v0.4.0/go.mod h1:Pe1W6UlPYUk/+wc/6KFhbORCfqzgYEpgQ3O5fPuL3H4=
+github.com/sagikazarmark/slog-shim v0.1.0 h1:diDBnUNK9N/354PgrxMywXnAwEr1QZcOr6gto+ugjYE=
+github.com/sagikazarmark/slog-shim v0.1.0/go.mod h1:SrcSrq8aKtyuqEI1uvTDTK1arOWRIczQRv+GVI1AkeQ=
+github.com/samber/lo v1.52.0 h1:Rvi+3BFHES3A8meP33VPAxiBZX/Aws5RxrschYGjomw=
+github.com/samber/lo v1.52.0/go.mod h1:4+MXEGsJzbKGaUEQFKBq2xtfuznW9oz/WrgyzMzRoM0=
+github.com/samber/mo v1.16.0 h1:qpEPCI63ou6wXlsNDMLE0IIN8A+devbGX/K1xdgr4b4=
+github.com/samber/mo v1.16.0/go.mod h1:DlgzJ4SYhOh41nP1L9kh9rDNERuf8IqWSAs+gj2Vxag=
+github.com/sasha-s/go-deadlock v0.3.5 h1:tNCOEEDG6tBqrNDOX35j/7hL5FcFViG6awUGROb2NsU=
+github.com/sasha-s/go-deadlock v0.3.5/go.mod h1:bugP6EGbdGYObIlx7pUZtWqlvo8k9H6vCBBsiChJQ5U=
+github.com/shurcooL/sanitized_anchor_name v1.0.0/go.mod h1:1NzhyTcUVG4SuEtjjoZeVRXNmyL/1OwPU0+IJeTBvfc=
+github.com/sirupsen/logrus v1.9.3 h1:dueUQJ1C2q9oE3F7wvmSGAaVtTmUizReu6fjN8uqzbQ=
+github.com/sirupsen/logrus v1.9.3/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ=
+github.com/smartystreets/assertions v1.2.0 h1:42S6lae5dvLc7BrLu/0ugRtcFVjoJNMC/N3yZFZkDFs=
+github.com/smartystreets/assertions v1.2.0/go.mod h1:tcbTF8ujkAEcZ8TElKY+i30BzYlVhC/LOxJk7iOWnoo=
+github.com/smartystreets/goconvey v1.7.2 h1:9RBaZCeXEQ3UselpuwUQHltGVXvdwm6cv1hgR6gDIPg=
+github.com/smartystreets/goconvey v1.7.2/go.mod h1:Vw0tHAZW6lzCRk3xgdin6fKYcG+G3Pg9vgXWeJpQFMM=
+github.com/sourcegraph/conc v0.3.0 h1:OQTbbt6P72L20UqAkXXuLOj79LfEanQ+YQFNpLA9ySo=
+github.com/sourcegraph/conc v0.3.0/go.mod h1:Sdozi7LEKbFPqYX2/J+iBAM6HpqSLTASQIKqDmF7Mt0=
+github.com/spaolacci/murmur3 v1.1.0 h1:7c1g84S4BPRrfL5Xrdp6fOJ206sU9y293DDHaoy0bLI=
+github.com/spaolacci/murmur3 v1.1.0/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA=
+github.com/spf13/afero v1.11.0 h1:WJQKhtpdm3v2IzqG8VMqrr6Rf3UYpEF239Jy9wNepM8=
+github.com/spf13/afero v1.11.0/go.mod h1:GH9Y3pIexgf1MTIWtNGyogA5MwRIDXGUr+hbWNoBjkY=
+github.com/spf13/cast v1.8.0 h1:gEN9K4b8Xws4EX0+a0reLmhq8moKn7ntRlQYgjPeCDk=
+github.com/spf13/cast v1.8.0/go.mod h1:ancEpBxwJDODSW/UG4rDrAqiKolqNNh2DX3mk86cAdo=
+github.com/spf13/pflag v1.0.6 h1:jFzHGLGAlb3ruxLB8MhbI6A8+AQX/2eW4qeyNZXNp2o=
+github.com/spf13/pflag v1.0.6/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
+github.com/spf13/viper v1.19.0 h1:RWq5SEjt8o25SROyN3z2OrDB9l7RPd3lwTWU8EcEdcI=
+github.com/spf13/viper v1.19.0/go.mod h1:GQUN9bilAbhU/jgc1bKs99f/suXKeUMct8Adx5+Ntkg=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
+github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
+github.com/stretchr/objx v0.5.2 h1:xuMeJ0Sdp5ZMRXx/aWO6RZxdr3beISkG5/G/aIRr3pY=
+github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA=
+github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA=
+github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
+github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
+github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
+github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
+github.com/subosito/gotenv v1.6.0 h1:9NlTDc1FTs4qu0DDq7AEtTPNw6SVm7uBMsUCUjABIf8=
+github.com/subosito/gotenv v1.6.0/go.mod h1:Dk4QP5c2W3ibzajGcXpNraDfq2IrhjMIvMSWPKKo0FU=
+github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7 h1:epCh84lMvA70Z7CTTCmYQn2CKbY8j86K7/FAIr141uY=
+github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7/go.mod h1:q4W45IWZaF22tdD+VEXcAWRA037jwmWEB5VWYORlTpc=
+github.com/ucarion/urlpath v0.0.0-20200424170820-7ccc79b76bbb h1:Ywfo8sUltxogBpFuMOFRrrSifO788kAFxmvVw31PtQQ=
+github.com/ucarion/urlpath v0.0.0-20200424170820-7ccc79b76bbb/go.mod h1:ikPs9bRWicNw3S7XpJ8sK/smGwU9WcSVU3dy9qahYBM=
+github.com/urfave/cli v1.22.10/go.mod h1:Gos4lmkARVdJ6EkW0WaNv/tZAAMe9V7XWyB60NtXRu0=
+github.com/warpfork/go-wish v0.0.0-20220906213052-39a1cc7a02d0 h1:GDDkbFiaK8jsSDJfjId/PEGEShv6ugrt4kYsC5UIDaQ=
+github.com/warpfork/go-wish v0.0.0-20220906213052-39a1cc7a02d0/go.mod h1:x6AKhvSSexNrVSrViXSHUEbICjmGXhtgABaHIySUSGw=
+github.com/whyrusleeping/cbor-gen v0.2.1-0.20241030202151-b7a6831be65e h1:28X54ciEwwUxyHn9yrZfl5ojgF4CBNLWX7LR0rvBkf4=
+github.com/whyrusleeping/cbor-gen v0.2.1-0.20241030202151-b7a6831be65e/go.mod h1:pM99HXyEbSQHcosHc0iW7YFmwnscr+t9Te4ibko05so=
+github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
+github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
+gitlab.com/yawning/secp256k1-voi v0.0.0-20230925100816-f2616030848b h1:CzigHMRySiX3drau9C6Q5CAbNIApmLdat5jPMqChvDA=
+gitlab.com/yawning/secp256k1-voi v0.0.0-20230925100816-f2616030848b/go.mod h1:/y/V339mxv2sZmYYR64O07VuCpdNZqCTwO8ZcouTMI8=
+gitlab.com/yawning/tuplehash v0.0.0-20230713102510-df83abbf9a02 h1:qwDnMxjkyLmAFgcfgTnfJrmYKWhHnci3GjDqcZp1M3Q=
+gitlab.com/yawning/tuplehash v0.0.0-20230713102510-df83abbf9a02/go.mod h1:JTnUj0mpYiAsuZLmKjTx/ex3AtMowcCgnE7YNyCEP0I=
+go.etcd.io/bbolt v1.4.0-alpha.0.0.20240404170359-43604f3112c5 h1:qxen9oVGzDdIRP6ejyAJc760RwW4SnVDiTYTzwnXuxo=
+go.etcd.io/bbolt v1.4.0-alpha.0.0.20240404170359-43604f3112c5/go.mod h1:eW0HG9/oHQhvRCvb1/pIXW4cOvtDqeQK+XSi3TnwaXY=
+go.opentelemetry.io/auto/sdk v1.1.0 h1:cH53jehLUN6UFLY71z+NDOiNJqDdPRaXzTel0sJySYA=
+go.opentelemetry.io/auto/sdk v1.1.0/go.mod h1:3wSPjt5PWp2RhlCcmmOial7AvC4DQqZb7a7wCow3W8A=
+go.opentelemetry.io/otel v1.37.0 h1:9zhNfelUvx0KBfu/gb+ZgeAfAgtWrfHJZcAqFC228wQ=
+go.opentelemetry.io/otel v1.37.0/go.mod h1:ehE/umFRLnuLa/vSccNq9oS1ErUlkkK71gMcN34UG8I=
+go.opentelemetry.io/otel/metric v1.37.0 h1:mvwbQS5m0tbmqML4NqK+e3aDiO02vsf/WgbsdpcPoZE=
+go.opentelemetry.io/otel/metric v1.37.0/go.mod h1:04wGrZurHYKOc+RKeye86GwKiTb9FKm1WHtO+4EVr2E=
+go.opentelemetry.io/otel/sdk v1.37.0 h1:ItB0QUqnjesGRvNcmAcU0LyvkVyGJ2xftD29bWdDvKI=
+go.opentelemetry.io/otel/sdk v1.37.0/go.mod h1:VredYzxUvuo2q3WRcDnKDjbdvmO0sCzOvVAiY+yUkAg=
+go.opentelemetry.io/otel/sdk/metric v1.32.0 h1:rZvFnvmvawYb0alrYkjraqJq0Z4ZUJAiyYCU9snn1CU=
+go.opentelemetry.io/otel/sdk/metric v1.32.0/go.mod h1:PWeZlq0zt9YkYAp3gjKZ0eicRYvOh1Gd+X99x6GHpCQ=
+go.opentelemetry.io/otel/trace v1.37.0 h1:HLdcFNbRQBE2imdSEgm/kwqmQj1Or1l/7bW6mxVK7z4=
+go.opentelemetry.io/otel/trace v1.37.0/go.mod h1:TlgrlQ+PtQO5XFerSPUYG0JSgGyryXewPGyayAWSBS0=
+go.uber.org/multierr v1.11.0 h1:blXXJkSxSSfBVBlC76pxqeO+LN3aDfLQo+309xJstO0=
+go.uber.org/multierr v1.11.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y=
+golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
+golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
+golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
+golang.org/x/crypto v0.41.0 h1:WKYxWedPGCTVVl5+WHSSrOBT0O8lx32+zxmHxijgXp4=
+golang.org/x/crypto v0.41.0/go.mod h1:pO5AFd7FA68rFak7rOAGVuygIISepHftHnr8dr6+sUc=
+golang.org/x/exp v0.0.0-20250620022241-b7579e27df2b h1:M2rDM6z3Fhozi9O7NWsxAkg/yqS/lQJ6PmkyIV3YP+o=
+golang.org/x/exp v0.0.0-20250620022241-b7579e27df2b/go.mod h1:3//PLf8L/X+8b4vuAfHzxeRUl04Adcb341+IGKfnqS8=
+golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
+golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
+golang.org/x/mod v0.27.0 h1:kb+q2PyFnEADO2IEF935ehFUXlWiNjJWtRNgBLSfbxQ=
+golang.org/x/mod v0.27.0/go.mod h1:rWI627Fq0DEoudcK+MBkNkCe0EetEaDSwJJkCcjpazc=
+golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20200520004742-59133d7f0dd7/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
+golang.org/x/net v0.0.0-20200813134508-3edf25e44fcc/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
+golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
+golang.org/x/net v0.43.0 h1:lat02VYK2j4aLzMzecihNvTlJNQUq316m2Mr9rnM6YE=
+golang.org/x/net v0.43.0/go.mod h1:vhO1fvI4dGsIjh73sWfUVjj3N7CA9WkKJNQm2svM6Jg=
+golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.16.0 h1:ycBJEhp9p4vXvUZNszeOq0kGTPghopOL8q0fq3vstxw=
+golang.org/x/sync v0.16.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA=
+golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190904154756-749cb33beabd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191005200804-aed5e4c7ecf9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191120155948-bd437916bb0e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200519105757-fe76b779f299/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200814200057-3d37ad5750ed/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.21.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/sys v0.36.0 h1:KVRy2GtZBrk1cBYA7MKu5bEZFxQk4NIDV6RLVcC8o0k=
+golang.org/x/sys v0.36.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
+golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
+golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/text v0.28.0 h1:rhazDwis8INMIwQ4tpjLDzUhx6RlXqZNPEM0huQojng=
+golang.org/x/text v0.28.0/go.mod h1:U8nCwOR8jO/marOQ0QbDiOngZVEBB7MAiitBuMjXiNU=
+golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20190328211700-ab21143f2384/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
+golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
+golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
+golang.org/x/tools v0.36.0 h1:kWS0uv/zsvHEle1LbV5LE8QujrxB3wfQyxHfhOk0Qkg=
+golang.org/x/tools v0.36.0/go.mod h1:WBDiHKJK8YgLHlcQPYQzNCkUxUypCaa5ZegCVutKm+s=
+golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20231012003039-104605ab7028 h1:+cNy6SZtPcJQH3LJVLOSmiC7MMxXNOb3PU/VUEz+EhU=
+golang.org/x/xerrors v0.0.0-20231012003039-104605ab7028/go.mod h1:NDW/Ps6MPRej6fsCIbMTohpP40sJ/P/vI1MoTEGwX90=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20241202173237-19429a94021a h1:hgh8P4EuoxpsuKMXX/To36nOFD7vixReXgn8lPGnt+o=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20241202173237-19429a94021a/go.mod h1:5uTbfoYQed2U9p3KIj2/Zzm02PYhndfdmML0qC3q3FU=
+google.golang.org/grpc v1.70.0 h1:pWFv03aZoHzlRKHWicjsZytKAiYCtNS0dHbXnIdq7jQ=
+google.golang.org/grpc v1.70.0/go.mod h1:ofIJqVKDXx/JiXrwr2IG4/zwdH9txy3IlF40RmcJSQw=
+google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8=
+google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0=
+google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM=
+google.golang.org/protobuf v1.20.1-0.20200309200217-e05f789c0967/go.mod h1:A+miEFZTKqfCUM6K7xSMQL9OKL/b6hQv+e19PK+JZNE=
+google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzikPIcrTAo=
+google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
+google.golang.org/protobuf v1.36.7 h1:IgrO7UwFQGJdRNXH/sQux4R1Dj1WAKcLElzeeRaXV2A=
+google.golang.org/protobuf v1.36.7/go.mod h1:jduwjTPXsFjZGTmRluh+L6NjiWu7pchiJ2/5YcXBHnY=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
+gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
+gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys=
+gopkg.in/ini.v1 v1.67.0 h1:Dgnx+6+nfE+IfzjUEISNeydPJh9AXNNsWbGP9KzCsOA=
+gopkg.in/ini.v1 v1.67.0/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k=
+gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 h1:uRGJdciOHaEIrze2W8Q3AKkepLTh2hOroT7a+7czfdQ=
+gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw=
+gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.3.0/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+lukechampine.com/blake3 v1.2.1 h1:YuqqRuaqsGV71BV/nm9xlI0MKUv4QC54jQnBChWbGnI=
+lukechampine.com/blake3 v1.2.1/go.mod h1:0OFRp7fBtAylGVCO40o87sbupkyIGgbpv1+M1k1LM6k=

httpapi/broadcast.go

···
+package httpapi
+
+import (
+	"context"
+	"time"
+
+	abci "github.com/cometbft/cometbft/abci/types"
+	mempl "github.com/cometbft/cometbft/mempool"
+	"github.com/cometbft/cometbft/node"
+	"github.com/cometbft/cometbft/rpc/core"
+	ctypes "github.com/cometbft/cometbft/rpc/core/types"
+	"github.com/cometbft/cometbft/types"
+	"github.com/palantir/stacktrace"
+)
+
+func broadcastTxCommit(ctx context.Context, node *node.Node, subscriber string, tx types.Tx) (*ctypes.ResultBroadcastTxCommit, error) {
+	eventBus := node.EventBus()
+	mempool := node.Mempool()
+	// Subscribe to tx being committed in block.
+	subCtx, cancel := context.WithTimeout(ctx, core.SubscribeTimeout)
+	defer cancel()
+	q := types.EventQueryTxFor(tx)
+	txSub, err := eventBus.Subscribe(subCtx, subscriber, q)
+	if err != nil {
+		return nil, stacktrace.Propagate(err, "failed to subscribe to tx")
+	}
+	defer func() {
+		err := eventBus.Unsubscribe(context.Background(), subscriber, q)
+		_ = err
+	}()
+
+	// Broadcast tx and wait for CheckTx result
+	checkTxResCh := make(chan *abci.ResponseCheckTx, 1)
+	err = mempool.CheckTx(tx, func(res *abci.ResponseCheckTx) {
+		select {
+		case <-ctx.Done():
+		case checkTxResCh <- res:
+		}
+	}, mempl.TxInfo{})
+	if err != nil {
+		return nil, stacktrace.Propagate(err, "error on broadcastTxCommit")
+	}
+	select {
+	case <-ctx.Done():
+		return nil, stacktrace.Propagate(ctx.Err(), "broadcast confirmation not received")
+	case checkTxRes := <-checkTxResCh:
+		if checkTxRes.Code != abci.CodeTypeOK {
+			return &ctypes.ResultBroadcastTxCommit{
+				CheckTx:  *checkTxRes,
+				TxResult: abci.ExecTxResult{},
+				Hash:     tx.Hash(),
+			}, nil
+		}
+
+		// Wait for the tx to be included in a block or timeout.
+		select {
+		case msg := <-txSub.Out(): // The tx was included in a block.
+			txResultEvent := msg.Data().(types.EventDataTx)
+			return &ctypes.ResultBroadcastTxCommit{
+				CheckTx:  *checkTxRes,
+				TxResult: txResultEvent.Result,
+				Hash:     tx.Hash(),
+				Height:   txResultEvent.Height,
+			}, nil
+		case <-txSub.Canceled():
+			err := txSub.Err()
+			if err == nil {
+				err = stacktrace.NewError("CometBFT exited")
+			}
+			return &ctypes.ResultBroadcastTxCommit{
+				CheckTx:  *checkTxRes,
+				TxResult: abci.ExecTxResult{},
+				Hash:     tx.Hash(),
+			}, stacktrace.Propagate(err, "txSub was canceled")
+		case <-time.After(node.Config().RPC.TimeoutBroadcastTxCommit):
+			return &ctypes.ResultBroadcastTxCommit{
+				CheckTx:  *checkTxRes,
+				TxResult: abci.ExecTxResult{},
+				Hash:     tx.Hash(),
+			}, stacktrace.NewError("timed out waiting for tx to be included in a block")
+		}
+	}
+}

httpapi/server.go

···
+package httpapi
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"net/http"
+	"time"
+
+	"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/rs/cors"
+
+	"tangled.org/gbl08ma/didplcbft/abciapp"
+	"tangled.org/gbl08ma/didplcbft/plc"
+)
+
+// Server represents the HTTP server for the PLC directory.
+type Server struct {
+	plc            plc.ReadPLC
+	router         *http.ServeMux
+	node           *node.Node
+	handlerTimeout time.Duration
+}
+
+// NewServer creates a new instance of the Server.
+func NewServer(plc plc.ReadPLC, node *node.Node, handlerTimeout time.Duration) *Server {
+	s := &Server{
+		plc:            plc,
+		router:         http.NewServeMux(),
+		node:           node,
+		handlerTimeout: handlerTimeout,
+	}
+	s.setupRoutes()
+	return s
+}
+
+// setupRoutes configures the routes for the server.
+func (s *Server) setupRoutes() {
+	s.router.HandleFunc("GET /{did}", s.makeDIDHandler(s.handleResolveDID))
+	s.router.HandleFunc("POST /{did}", s.makeDIDHandler(s.handleCreatePLC))
+	s.router.HandleFunc("GET /{did}/log", s.makeDIDHandler(s.handleGetPLCLog))
+	s.router.HandleFunc("GET /{did}/log/audit", s.makeDIDHandler(s.handleGetPLCAuditLog))
+	s.router.HandleFunc("GET /{did}/log/last", s.makeDIDHandler(s.handleGetLastOp))
+	s.router.HandleFunc("GET /{did}/data", s.makeDIDHandler(s.handleGetPLCData))
+	s.router.HandleFunc("GET /export", s.handleExport)
+}
+
+// makeDIDHandler creates a wrapper handler that extracts DID from URL path
+func (s *Server) makeDIDHandler(handler func(http.ResponseWriter, *http.Request, string)) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		handler(w, r, r.PathValue("did"))
+	}
+}
+
+// Serve starts the HTTP server on the specified address.
+func (s *Server) Serve(addr string) error {
+	handler := cors.Default().Handler(s.router)
+
+	timeoutMsg, _ := json.Marshal(map[string]string{"message": "Internal server timeout"})
+
+	handler = http.TimeoutHandler(handler, s.handlerTimeout, string(timeoutMsg))
+	return http.ListenAndServe(addr, handler)
+}
+
+// handleResolveDID handles the GET /{did} endpoint.
+func (s *Server) handleResolveDID(w http.ResponseWriter, r *http.Request, did string) {
+
+	ctx := context.Background()
+	doc, err := s.plc.Resolve(ctx, plc.CommittedTreeVersion, did)
+	if handlePLCError(w, err, did) {
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/did+ld+json")
+	json.NewEncoder(w).Encode(doc)
+}
+
+// handleCreatePLC handles the POST /{did} endpoint.
+func (s *Server) handleCreatePLC(w http.ResponseWriter, r *http.Request, did string) {
+
+	var op didplc.OpEnum
+	if err := json.NewDecoder(r.Body).Decode(&op); err != nil {
+		sendErrorResponse(w, http.StatusBadRequest, "Invalid operation")
+		return
+	}
+
+	if s.node == nil {
+		// Validate only
+		// Marshal the operation to JSON bytes for validation
+		opBytes, err := json.Marshal(op)
+		if err != nil {
+			sendErrorResponse(w, http.StatusBadRequest, "Invalid operation")
+			return
+		}
+
+		if err := s.plc.ValidateOperation(r.Context(), plc.CommittedTreeVersion, time.Now(), did, opBytes); err != nil {
+			sendErrorResponse(w, http.StatusBadRequest, "Invalid operation")
+			return
+		}
+		w.WriteHeader(http.StatusOK)
+		return
+	}
+
+	uuid, err := uuid.NewRandom()
+	if handlePLCError(w, err, "") {
+		return
+	}
+
+	tx := abciapp.Transaction[abciapp.CreatePlcOpArguments]{
+		Action: abciapp.TransactionActionCreatePlcOp,
+		Arguments: abciapp.CreatePlcOpArguments{
+			DID:       did,
+			Operation: &op,
+		},
+	}
+
+	txBytes, err := cbornode.DumpObject(tx)
+	if handlePLCError(w, err, "") {
+		return
+	}
+
+	// broadcastTxCommit will wait for inclusion, up until the TimeoutBroadcastTxCommit configured for the node, or until the context deadline expires
+	// in practice we expect operations to be included in about one second
+	result, err := broadcastTxCommit(r.Context(), s.node, uuid.String(), txBytes)
+	// TODO more robust error handling
+	if handlePLCError(w, err, "") {
+		return
+	}
+
+	if result.CheckTx.Code != 0 {
+		sendErrorResponse(w, http.StatusBadRequest, "Invalid operation")
+		return
+	}
+
+	if result.TxResult.Code != 0 {
+		sendErrorResponse(w, http.StatusBadRequest, "Invalid operation")
+		return
+	}
+
+	w.WriteHeader(http.StatusOK)
+
+}
+
+// handleGetPLCLog handles the GET /{did}/log endpoint.
+func (s *Server) handleGetPLCLog(w http.ResponseWriter, r *http.Request, did string) {
+	ops, err := s.plc.OperationLog(r.Context(), plc.CommittedTreeVersion, did)
+	if handlePLCError(w, err, did) {
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(ops)
+}
+
+// handleGetPLCAuditLog handles the GET /{did}/log/audit endpoint.
+func (s *Server) handleGetPLCAuditLog(w http.ResponseWriter, r *http.Request, did string) {
+	entries, err := s.plc.AuditLog(r.Context(), plc.CommittedTreeVersion, did)
+	if handlePLCError(w, err, did) {
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(entries)
+}
+
+// handleGetLastOp handles the GET /{did}/log/last endpoint.
+func (s *Server) handleGetLastOp(w http.ResponseWriter, r *http.Request, did string) {
+	op, err := s.plc.LastOperation(r.Context(), plc.CommittedTreeVersion, did)
+	if handlePLCError(w, err, did) {
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(op)
+}
+
+// handleGetPLCData handles the GET /{did}/data endpoint.
+func (s *Server) handleGetPLCData(w http.ResponseWriter, r *http.Request, did string) {
+	data, err := s.plc.Data(r.Context(), plc.CommittedTreeVersion, did)
+	if handlePLCError(w, err, did) {
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(data)
+}
+
+// handleExport handles the GET /export endpoint.
+func (s *Server) handleExport(w http.ResponseWriter, r *http.Request) {
+	query := r.URL.Query()
+	count := 1000 // The OpenAPI spec says the default is 10, but in practice the official server defaults to 1000
+	if c := query.Get("count"); c != "" {
+		if _, err := fmt.Sscanf(c, "%d", &count); err != nil {
+			sendErrorResponse(w, http.StatusBadRequest, "Invalid count parameter")
+			return
+		}
+	}
+
+	afterStr := query.Get("after")
+	after, err := syntax.ParseDatetime(afterStr)
+	if err != nil && afterStr != "" {
+		sendErrorResponse(w, http.StatusBadRequest, "Invalid after parameter")
+		return
+	}
+
+	entries, err := s.plc.Export(r.Context(), plc.CommittedTreeVersion, after.Time(), count)
+	if handlePLCError(w, err, "") {
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/jsonlines")
+	for _, entry := range entries {
+		json.NewEncoder(w).Encode(entry)
+	}
+}
+
+// handlePLCError handles errors from the PLC interface and sends the appropriate HTTP response.
+func handlePLCError(w http.ResponseWriter, err error, did string) bool {
+	if err == nil {
+		return false
+	}
+	switch {
+	case errors.Is(err, plc.ErrDIDNotFound):
+		sendErrorResponse(w, http.StatusNotFound, fmt.Sprintf("DID not registered: %s", did))
+	case errors.Is(err, plc.ErrDIDGone):
+		sendErrorResponse(w, http.StatusGone, fmt.Sprintf("DID not available: %s", did))
+	default:
+		sendErrorResponse(w, http.StatusInternalServerError, "Internal server error")
+	}
+	return true
+}
+
+// sendErrorResponse sends an error response with the specified status code and message.
+func sendErrorResponse(w http.ResponseWriter, statusCode int, message string) {
+	w.WriteHeader(statusCode)
+	json.NewEncoder(w).Encode(map[string]string{"message": message})
+}

httpapi/server_test.go

···
+package httpapi
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+	"time"
+
+	"github.com/did-method-plc/go-didplc"
+	"github.com/stretchr/testify/assert"
+	"tangled.org/gbl08ma/didplcbft/plc"
+)
+
+// MockReadPLC is a mock implementation of the ReadPLC interface for testing.
+type MockReadPLC struct {
+	shouldReturnError bool
+	errorType         string
+}
+
+func (m *MockReadPLC) ValidateOperation(ctx context.Context, atHeight plc.TreeVersion, at time.Time, did string, opBytes []byte) error {
+	if m.shouldReturnError {
+		switch m.errorType {
+		case "notfound":
+			return plc.ErrDIDNotFound
+		case "gone":
+			return plc.ErrDIDGone
+		}
+		return fmt.Errorf("internal error")
+	}
+	return nil
+}
+
+func (m *MockReadPLC) Resolve(ctx context.Context, atHeight plc.TreeVersion, did string) (didplc.Doc, error) {
+	if m.shouldReturnError {
+		switch m.errorType {
+		case "notfound":
+			return didplc.Doc{}, plc.ErrDIDNotFound
+		case "gone":
+			return didplc.Doc{}, plc.ErrDIDGone
+		}
+		return didplc.Doc{}, fmt.Errorf("internal error")
+	}
+	return didplc.Doc{
+		ID: "did:plc:test",
+	}, nil
+}
+
+func (m *MockReadPLC) OperationLog(ctx context.Context, atHeight plc.TreeVersion, did string) ([]didplc.OpEnum, error) {
+	if m.shouldReturnError {
+		if m.errorType == "notfound" {
+			return []didplc.OpEnum{}, plc.ErrDIDNotFound
+		}
+		return []didplc.OpEnum{}, fmt.Errorf("internal error")
+	}
+	return []didplc.OpEnum{}, nil
+}
+
+func (m *MockReadPLC) AuditLog(ctx context.Context, atHeight plc.TreeVersion, did string) ([]didplc.LogEntry, error) {
+	if m.shouldReturnError {
+		if m.errorType == "notfound" {
+			return []didplc.LogEntry{}, plc.ErrDIDNotFound
+		}
+		return []didplc.LogEntry{}, fmt.Errorf("internal error")
+	}
+	return []didplc.LogEntry{}, nil
+}
+
+func (m *MockReadPLC) LastOperation(ctx context.Context, atHeight plc.TreeVersion, did string) (didplc.OpEnum, error) {
+	if m.shouldReturnError {
+		if m.errorType == "notfound" {
+			return didplc.OpEnum{}, plc.ErrDIDNotFound
+		}
+		return didplc.OpEnum{}, fmt.Errorf("internal error")
+	}
+	return didplc.OpEnum{}, nil
+}
+
+func (m *MockReadPLC) Data(ctx context.Context, atHeight plc.TreeVersion, did string) (didplc.RegularOp, error) {
+	if m.shouldReturnError {
+		switch m.errorType {
+		case "notfound":
+			return didplc.RegularOp{}, plc.ErrDIDNotFound
+		case "gone":
+			return didplc.RegularOp{}, plc.ErrDIDGone
+		}
+		return didplc.RegularOp{}, fmt.Errorf("internal error")
+	}
+	return didplc.RegularOp{}, nil
+}
+
+func (m *MockReadPLC) Export(ctx context.Context, atHeight plc.TreeVersion, after time.Time, count int) ([]didplc.LogEntry, error) {
+	if m.shouldReturnError {
+		return []didplc.LogEntry{}, fmt.Errorf("internal error")
+	}
+	return []didplc.LogEntry{}, nil
+}
+
+func TestServer(t *testing.T) {
+	mockPLC := &MockReadPLC{}
+
+	t.Run("Test Resolve DID", func(t *testing.T) {
+		server := NewServer(mockPLC, nil, 15*time.Second)
+
+		req, err := http.NewRequest("GET", "/did:plc:test", nil)
+		assert.NoError(t, err)
+
+		rr := httptest.NewRecorder()
+		server.router.ServeHTTP(rr, req)
+
+		assert.Equal(t, http.StatusOK, rr.Code)
+		assert.Contains(t, rr.Body.String(), "did:plc:test")
+	})
+
+	t.Run("Test Resolve DID Not Found", func(t *testing.T) {
+		mockPLC := &MockReadPLC{shouldReturnError: true, errorType: "notfound"}
+		server := NewServer(mockPLC, nil, 15*time.Second)
+
+		req, err := http.NewRequest("GET", "/did:plc:test", nil)
+		assert.NoError(t, err)
+
+		rr := httptest.NewRecorder()
+		server.router.ServeHTTP(rr, req)
+
+		assert.Equal(t, http.StatusNotFound, rr.Code)
+		assert.Contains(t, rr.Body.String(), "DID not registered: did:plc:test")
+	})
+
+	t.Run("Test Resolve DID Gone", func(t *testing.T) {
+		mockPLC := &MockReadPLC{shouldReturnError: true, errorType: "gone"}
+		server := NewServer(mockPLC, nil, 15*time.Second)
+
+		req, err := http.NewRequest("GET", "/did:plc:test", nil)
+		assert.NoError(t, err)
+
+		rr := httptest.NewRecorder()
+		server.router.ServeHTTP(rr, req)
+
+		assert.Equal(t, http.StatusGone, rr.Code)
+		assert.Contains(t, rr.Body.String(), "DID not available: did:plc:test")
+	})
+
+	t.Run("Test Resolve DID Internal Error", func(t *testing.T) {
+		mockPLC := &MockReadPLC{shouldReturnError: true, errorType: "internal"}
+		server := NewServer(mockPLC, nil, 15*time.Second)
+
+		req, err := http.NewRequest("GET", "/did:plc:test", nil)
+		assert.NoError(t, err)
+
+		rr := httptest.NewRecorder()
+		server.router.ServeHTTP(rr, req)
+
+		assert.Equal(t, http.StatusInternalServerError, rr.Code)
+		assert.Contains(t, rr.Body.String(), "Internal server error")
+	})
+
+	t.Run("Test Create PLC Operation", func(t *testing.T) {
+		server := NewServer(mockPLC, nil, 15*time.Second)
+
+		op := map[string]interface{}{
+			"type":                "plc_operation",
+			"rotationKeys":        []string{"did:key:test"},
+			"verificationMethods": map[string]string{"atproto": "did:key:test"},
+			"alsoKnownAs":         []string{"at://test"},
+			"services":            map[string]interface{}{"atproto_pds": map[string]string{"type": "AtprotoPersonalDataServer", "endpoint": "https://test.com"}},
+			"prev":                nil,
+			"sig":                 "test",
+		}
+		opBytes, _ := json.Marshal(op)
+
+		req, err := http.NewRequest("POST", "/did:plc:test", bytes.NewBuffer(opBytes))
+		assert.NoError(t, err)
+
+		rr := httptest.NewRecorder()
+		server.router.ServeHTTP(rr, req)
+
+		assert.Equal(t, http.StatusOK, rr.Code)
+	})
+
+	t.Run("Test Get PLC Log", func(t *testing.T) {
+		server := NewServer(mockPLC, nil, 15*time.Second)
+
+		req, err := http.NewRequest("GET", "/did:plc:test/log", nil)
+		assert.NoError(t, err)
+
+		rr := httptest.NewRecorder()
+		server.router.ServeHTTP(rr, req)
+
+		assert.Equal(t, http.StatusOK, rr.Code)
+	})
+
+	t.Run("Test Get PLC Log Not Found", func(t *testing.T) {
+		mockPLC := &MockReadPLC{shouldReturnError: true, errorType: "notfound"}
+		server := NewServer(mockPLC, nil, 15*time.Second)
+
+		req, err := http.NewRequest("GET", "/did:plc:test/log", nil)
+		assert.NoError(t, err)
+
+		rr := httptest.NewRecorder()
+		server.router.ServeHTTP(rr, req)
+
+		assert.Equal(t, http.StatusNotFound, rr.Code)
+		assert.Contains(t, rr.Body.String(), "DID not registered: did:plc:test")
+	})
+
+	t.Run("Test Get PLC Audit Log", func(t *testing.T) {
+		server := NewServer(mockPLC, nil, 15*time.Second)
+
+		req, err := http.NewRequest("GET", "/did:plc:test/log/audit", nil)
+		assert.NoError(t, err)
+
+		rr := httptest.NewRecorder()
+		server.router.ServeHTTP(rr, req)
+
+		assert.Equal(t, http.StatusOK, rr.Code)
+	})
+
+	t.Run("Test Get Last Operation", func(t *testing.T) {
+		server := NewServer(mockPLC, nil, 15*time.Second)
+
+		req, err := http.NewRequest("GET", "/did:plc:test/log/last", nil)
+		assert.NoError(t, err)
+
+		rr := httptest.NewRecorder()
+		server.router.ServeHTTP(rr, req)
+
+		assert.Equal(t, http.StatusOK, rr.Code)
+	})
+
+	t.Run("Test Get Last Operation Internal Error", func(t *testing.T) {
+		mockPLC := &MockReadPLC{shouldReturnError: true, errorType: "internal"}
+		server := NewServer(mockPLC, nil, 15*time.Second)
+
+		req, err := http.NewRequest("GET", "/did:plc:test/log/last", nil)
+		assert.NoError(t, err)
+
+		rr := httptest.NewRecorder()
+		server.router.ServeHTTP(rr, req)
+
+		assert.Equal(t, http.StatusInternalServerError, rr.Code)
+		assert.Contains(t, rr.Body.String(), "Internal server error")
+	})
+
+	t.Run("Test Get PLC Data", func(t *testing.T) {
+		server := NewServer(mockPLC, nil, 15*time.Second)
+
+		req, err := http.NewRequest("GET", "/did:plc:test/data", nil)
+		assert.NoError(t, err)
+
+		rr := httptest.NewRecorder()
+		server.router.ServeHTTP(rr, req)
+
+		assert.Equal(t, http.StatusOK, rr.Code)
+	})
+
+	t.Run("Test Get PLC Data Not Found", func(t *testing.T) {
+		mockPLC := &MockReadPLC{shouldReturnError: true, errorType: "notfound"}
+		server := NewServer(mockPLC, nil, 15*time.Second)
+
+		req, err := http.NewRequest("GET", "/did:plc:test/data", nil)
+		assert.NoError(t, err)
+
+		rr := httptest.NewRecorder()
+		server.router.ServeHTTP(rr, req)
+
+		assert.Equal(t, http.StatusNotFound, rr.Code)
+		assert.Contains(t, rr.Body.String(), "DID not registered: did:plc:test")
+	})
+
+	t.Run("Test Export", func(t *testing.T) {
+		server := NewServer(mockPLC, nil, 15*time.Second)
+
+		req, err := http.NewRequest("GET", "/export?count=10", nil)
+		assert.NoError(t, err)
+
+		rr := httptest.NewRecorder()
+		server.router.ServeHTTP(rr, req)
+
+		assert.Equal(t, http.StatusOK, rr.Code)
+	})
+
+	t.Run("Test Export Internal Error", func(t *testing.T) {
+		mockPLC := &MockReadPLC{shouldReturnError: true, errorType: "internal"}
+		server := NewServer(mockPLC, nil, 15*time.Second)
+
+		req, err := http.NewRequest("GET", "/export?count=10", nil)
+		assert.NoError(t, err)
+
+		rr := httptest.NewRecorder()
+		server.router.ServeHTTP(rr, req)
+
+		assert.Equal(t, http.StatusInternalServerError, rr.Code)
+		assert.Contains(t, rr.Body.String(), "Internal server error")
+	})
+}

importer/importer.go

···
+package importer
+
+// placeholder

importer/importer_test.go

···
+package importer_test
+
+import (
+	"bufio"
+	"context"
+	"encoding/json"
+	"fmt"
+	"iter"
+	"net/http"
+	"strings"
+	"sync"
+	"sync/atomic"
+	"testing"
+	"time"
+
+	"github.com/cometbft/cometbft/crypto/tmhash"
+	"github.com/cometbft/cometbft/libs/bytes"
+	rpchttp "github.com/cometbft/cometbft/rpc/client/http"
+	"github.com/did-method-plc/go-didplc"
+	cbornode "github.com/ipfs/go-ipld-cbor"
+	"github.com/puzpuzpuz/xsync/v4"
+	"github.com/samber/lo"
+	"github.com/stretchr/testify/require"
+	"tangled.org/gbl08ma/didplcbft/abciapp"
+)
+
+func TestImportV2(t *testing.T) {
+	c, err := rpchttp.New("http://localhost:26100", "/websocket")
+	require.NoError(t, err)
+
+	ctx := t.Context()
+
+	entryCh := make(chan *didplc.LogEntry)
+	reprocessCh := make(chan *didplc.LogEntry, 1000)
+	awaitCh := make(chan *didplc.LogEntry, 100)
+	doneCh := make(chan *didplc.LogEntry, 100)
+	exitCh := make(chan struct{})
+
+	totalAwaiting := xsync.NewMap[string, struct{}]()
+
+	var wg sync.WaitGroup
+	noMoreNewEntries := atomic.Bool{}
+	wg.Go(func() {
+		for entry := range iterateOverExport(ctx, "2023-10-10T00:00:00.000Z") {
+			if totalAwaiting.Size() > 5000 {
+				for totalAwaiting.Size() > 1000 {
+					time.Sleep(1 * time.Second)
+				}
+			}
+			entryCh <- &entry
+		}
+		noMoreNewEntries.Store(true)
+		close(entryCh)
+	})
+
+	wg.Go(func() {
+		awaitingByDID := make(map[string][]*didplc.LogEntry)
+		inReprocessCh := make(map[string]struct{})
+		ticker := time.NewTicker(1 * time.Second)
+		defer ticker.Stop()
+
+		checkReprocess := func() {
+			toDelete := make(map[string]struct{})
+			for did, q := range awaitingByDID {
+				if len(q) > 0 {
+					if _, ok := inReprocessCh[q[0].CID]; !ok {
+						select {
+						case reprocessCh <- q[0]:
+							t.Logf("DID %s has %d operations awaiting", did, len(q))
+							inReprocessCh[q[0].CID] = struct{}{}
+						default:
+						}
+					}
+				} else {
+					toDelete[did] = struct{}{}
+				}
+			}
+			for v := range toDelete {
+				delete(awaitingByDID, v)
+			}
+			if len(awaitingByDID) == 0 && noMoreNewEntries.Load() {
+				close(reprocessCh)
+			}
+		}
+		for {
+			select {
+			case <-exitCh:
+				return
+			case entry := <-awaitCh:
+				totalAwaiting.Store(entry.CID, struct{}{})
+				delete(inReprocessCh, entry.CID)
+
+				if !lo.ContainsBy(awaitingByDID[entry.DID], func(e *didplc.LogEntry) bool {
+					return e.CID == entry.CID
+				}) {
+					awaitingByDID[entry.DID] = append(awaitingByDID[entry.DID], entry)
+				}
+			case entry := <-doneCh:
+				totalAwaiting.Delete(entry.CID)
+				delete(inReprocessCh, entry.CID)
+				if q, ok := awaitingByDID[entry.DID]; ok {
+					awaitingByDID[entry.DID] = lo.Filter(q, func(e *didplc.LogEntry, _ int) bool {
+						return e.CID != entry.CID
+					})
+					if len(awaitingByDID[entry.DID]) == 0 {
+						delete(awaitingByDID, entry.DID)
+					}
+					checkReprocess()
+				}
+			case <-ticker.C:
+				checkReprocess()
+			}
+		}
+	})
+
+	totalSkipped := 0
+	totalSubmitted := 0
+	for entry := range lo.FanIn(100, entryCh, reprocessCh) {
+		tx := abciapp.Transaction[abciapp.CreatePlcOpArguments]{
+			Action: abciapp.TransactionActionCreatePlcOp,
+			Arguments: abciapp.CreatePlcOpArguments{
+				DID:       entry.DID,
+				Operation: &entry.Operation,
+			},
+		}
+
+		out, err := cbornode.DumpObject(tx)
+		require.NoError(t, err)
+
+		query := fmt.Sprintf("tx.hash='%s'", bytes.HexBytes(tmhash.Sum(out)).String())
+		result, err := c.TxSearch(ctx, query, false, nil, nil, "")
+		require.NoError(t, err)
+		if result.TotalCount > 0 {
+			totalSkipped++
+			if totalSkipped%2000 == 0 {
+				t.Logf("Skipped %d transactions, createdAt %s", totalSkipped, entry.CreatedAt)
+			}
+			continue
+		}
+
+		//st := time.Now()
+		broadcastResult, err := c.BroadcastTxSync(ctx, out)
+		/*if d := time.Since(st); d > 50*time.Millisecond {
+			t.Logf("broadcast took %v %s %s %v %v", d, entry.DID, entry.CID, err, broadcastResult)
+		}*/
+		if err != nil && strings.Contains(err.Error(), "tx already exists in cache") {
+			totalSkipped++
+			doneCh <- entry
+			t.Logf("Skipped %d transactions, createdAt %s", totalSkipped, entry.CreatedAt)
+			continue
+		}
+
+		if err != nil && strings.Contains(err.Error(), "mempool is full") {
+			t.Logf("Mempool is full, waiting...")
+			time.Sleep(20 * time.Second)
+			awaitCh <- entry
+			continue
+		}
+		require.NoError(t, err)
+
+		if broadcastResult.Code != 0 {
+			query := fmt.Sprintf("tx.hash='%s'", broadcastResult.Hash)
+			result, err := c.TxSearch(ctx, query, false, nil, nil, "")
+			require.NoError(t, err)
+			if result.TotalCount > 0 {
+				totalSkipped++
+				t.Logf("Skipped %d transactions, createdAt %s", totalSkipped, entry.CreatedAt)
+				continue
+			}
+
+			awaitCh <- entry
+
+			continue
+		}
+
+		doneCh <- entry
+
+		totalSubmitted++
+
+		t.Logf("Submitted %d transactions, createdAt %s, %d awaiting", totalSubmitted, entry.CreatedAt, totalAwaiting.Size())
+	}
+
+	exitCh <- struct{}{}
+	wg.Wait()
+}
+
+func iterateOverExport(ctx context.Context, startAt string) 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 {
+			req, err := http.NewRequestWithContext(ctx, "GET", baseURL, nil)
+			if err != nil {
+				return // Failed to create request
+			}
+
+			req.Header.Set("User-Agent", "go-did-method-plc")
+
+			q := req.URL.Query()
+			q.Add("count", fmt.Sprint(batchSize))
+			if after != "" {
+				q.Add("after", after)
+			}
+			req.URL.RawQuery = q.Encode()
+
+			resp, err := client.Do(req)
+			if err != nil {
+				return // Failed to make request
+			}
+			defer resp.Body.Close()
+
+			if resp.StatusCode != http.StatusOK {
+				return // Non-200 status code
+			}
+
+			entries := make([]didplc.LogEntry, 0, batchSize)
+
+			// Read response body
+			s := bufio.NewScanner(resp.Body)
+			receivedEntries := 0
+			for s.Scan() {
+				var entry didplc.LogEntry
+				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{}{}
+				}
+				receivedEntries++
+			}
+			if s.Err() != nil {
+				return // handle scan error
+			}
+
+			if len(entries) == 0 {
+				return
+			}
+
+			// Process each entry
+			var lastCreatedAt string
+			for _, entry := range entries {
+				lastCreatedAt = entry.CreatedAt
+				if !yield(entry) {
+					return
+				}
+			}
+
+			if receivedEntries < batchSize {
+				return
+			}
+
+			after = lastCreatedAt
+
+			// Small delay to be respectful to the API
+			time.Sleep(100 * time.Millisecond)
+		}
+	}
+}

main.go

···
+package main
+
+import (
+	"flag"
+	"fmt"
+	"log"
+	"os"
+	"os/signal"
+	"path/filepath"
+	"sync"
+	"syscall"
+	"time"
+
+	"github.com/cometbft/cometbft/p2p"
+	"github.com/cometbft/cometbft/privval"
+	"github.com/cometbft/cometbft/proxy"
+	"github.com/samber/lo"
+	"tangled.org/gbl08ma/didplcbft/abciapp"
+
+	bftconfig "github.com/cometbft/cometbft/config"
+	cmtflags "github.com/cometbft/cometbft/libs/cli/flags"
+	cmtlog "github.com/cometbft/cometbft/libs/log"
+	nm "github.com/cometbft/cometbft/node"
+	"github.com/dgraph-io/badger/v4"
+	"github.com/dgraph-io/badger/v4/options"
+	"github.com/spf13/viper"
+)
+
+var homeDir string
+
+func init() {
+	flag.StringVar(&homeDir, "data-dir", "", "Path to the CometBFT config directory (if empty, uses ./didplcbft-data)")
+}
+
+func main() {
+	flag.Parse()
+	if homeDir == "" {
+		homeDir = filepath.Join(lo.Must(os.Getwd()), "didplcbft-data")
+	}
+
+	config := bftconfig.DefaultConfig()
+	config.SetRoot(homeDir)
+	viper.SetConfigFile(fmt.Sprintf("%s/%s", homeDir, "config/config.toml"))
+
+	if err := viper.ReadInConfig(); err != nil {
+		log.Fatalf("Reading config: %v", err)
+	}
+	if err := viper.Unmarshal(config); err != nil {
+		log.Fatalf("Decoding config: %v", err)
+	}
+	if err := config.ValidateBasic(); err != nil {
+		log.Fatalf("Invalid configuration data: %v", err)
+	}
+	badgerDBPath := filepath.Join(homeDir, "badger")
+	badgerDB, err := badger.Open(badger.
+		DefaultOptions(badgerDBPath).
+		WithBlockSize(8 * 1024).
+		WithMemTableSize(256 << 20).
+		WithCompression(options.ZSTD))
+	if err != nil {
+		log.Fatalf("Opening badger database: %v", err)
+	}
+
+	for err == nil {
+		err = badgerDB.RunValueLogGC(0.5)
+	}
+
+	var wg sync.WaitGroup
+	closeGoroutinesCh := make(chan struct{})
+	wg.Go(func() {
+		ticker := time.NewTicker(5 * time.Minute)
+		defer ticker.Stop()
+		for {
+			select {
+			case <-ticker.C:
+				var err error
+				for err == nil {
+					err = badgerDB.RunValueLogGC(0.5)
+				}
+			case <-closeGoroutinesCh:
+				return
+			}
+		}
+	})
+
+	defer func() {
+		if err := badgerDB.Close(); err != nil {
+			log.Printf("Closing badger database: %v", err)
+		}
+	}()
+
+	app, plc, cleanup, err := abciapp.NewDIDPLCApplication(badgerDB, filepath.Join(homeDir, "snapshots"))
+	if err != nil {
+		log.Fatalf("failed to create DIDPLC application: %v", err)
+	}
+	defer cleanup()
+
+	_ = plc // TODO
+
+	pv := privval.LoadFilePV(
+		config.PrivValidatorKeyFile(),
+		config.PrivValidatorStateFile(),
+	)
+
+	nodeKey, err := p2p.LoadNodeKey(config.NodeKeyFile())
+	if err != nil {
+		log.Fatalf("failed to load node's key: %v", err)
+	}
+
+	logger := cmtlog.NewTMLogger(cmtlog.NewSyncWriter(os.Stdout))
+	logger, err = cmtflags.ParseLogLevel(config.LogLevel, logger, bftconfig.DefaultLogLevel)
+
+	if err != nil {
+		log.Fatalf("failed to parse log level: %v", err)
+	}
+
+	node, err := nm.NewNode(
+		config,
+		pv,
+		nodeKey,
+		proxy.NewLocalClientCreator(app),
+		nm.DefaultGenesisDocProviderFunc(config),
+		bftconfig.DefaultDBProvider,
+		nm.DefaultMetricsProvider(config.Instrumentation),
+		logger,
+	)
+
+	if err != nil {
+		log.Fatalf("Creating node: %v", err)
+	}
+
+	err = node.Start()
+	if err != nil {
+		log.Fatalf("Starting node: %v", err)
+	}
+	defer func() {
+		node.Stop()
+		node.Wait()
+	}()
+
+	c := make(chan os.Signal, 1)
+	signal.Notify(c, os.Interrupt, syscall.SIGTERM)
+	<-c
+	close(closeGoroutinesCh)
+	wg.Wait()
+}

plc/impl.go

···
+package plc
+
+import (
+	"context"
+	"iter"
+	"sync"
+	"time"
+
+	"github.com/bluesky-social/indigo/atproto/syntax"
+	"github.com/cosmos/iavl"
+	"github.com/did-method-plc/go-didplc"
+	"github.com/ipfs/go-cid"
+	"github.com/palantir/stacktrace"
+	"github.com/samber/lo"
+	"tangled.org/gbl08ma/didplcbft/store"
+)
+
+type TreeProvider interface {
+	MutableTree() (*iavl.MutableTree, error)
+	ImmutableTree(version TreeVersion) (store.PossiblyMutableTree, error)
+}
+
+type plcImpl struct {
+	mu           sync.Mutex // probably redundant, but let's keep for now
+	treeProvider TreeProvider
+	validator    OperationValidator
+}
+
+var _ PLC = (*plcImpl)(nil)
+
+func NewPLC(treeProvider TreeProvider) *plcImpl {
+	p := &plcImpl{
+		treeProvider: treeProvider,
+	}
+
+	p.validator = NewV0OperationValidator(&inMemoryAuditLogFetcher{
+		plc: p,
+	})
+	return p
+}
+
+func (plc *plcImpl) ValidateOperation(ctx context.Context, atHeight TreeVersion, at time.Time, did string, opBytes []byte) error {
+	plc.mu.Lock()
+	defer plc.mu.Unlock()
+
+	timestamp := syntax.Datetime(at.Format(syntax.AtprotoDatetimeLayout))
+
+	// TODO set true to false only while importing old ops
+	_, err := plc.validator.Validate(atHeight, timestamp, did, opBytes, true)
+	if err != nil {
+		return stacktrace.Propagate(err, "operation failed validation")
+	}
+
+	return nil
+}
+
+func (plc *plcImpl) ExecuteOperation(ctx context.Context, t time.Time, did string, opBytes []byte) (cid.Cid, error) {
+	plc.mu.Lock()
+	defer plc.mu.Unlock()
+
+	timestamp := syntax.Datetime(t.Format(syntax.AtprotoDatetimeLayout))
+
+	// TODO set true to false only while importing old ops
+	effects, err := plc.validator.Validate(WorkingTreeVersion, timestamp, did, opBytes, true)
+	if err != nil {
+		return cid.Undef, stacktrace.Propagate(err, "operation failed validation")
+	}
+
+	tree, err := plc.treeProvider.MutableTree()
+	if err != nil {
+		return cid.Undef, stacktrace.Propagate(err, "failed to obtain mutable tree")
+	}
+
+	err = store.Tree.StoreOperation(tree, effects.NewLogEntry, effects.NewOperationIndex, effects.NullifiedEntriesStartingIndex)
+	if err != nil {
+		return cid.Undef, stacktrace.Propagate(err, "failed to commit operation")
+	}
+
+	return effects.NewOperationCID, nil
+}
+
+func (plc *plcImpl) Resolve(ctx context.Context, atHeight TreeVersion, did string) (didplc.Doc, error) {
+	plc.mu.Lock()
+	defer plc.mu.Unlock()
+
+	tree, err := plc.treeProvider.ImmutableTree(atHeight)
+	if err != nil {
+		return didplc.Doc{}, stacktrace.Propagate(err, "failed to obtain immutable tree")
+	}
+
+	l, _, err := store.Tree.AuditLog(tree, did, false)
+	if err != nil {
+		return didplc.Doc{}, stacktrace.Propagate(err, "")
+	}
+
+	if len(l) == 0 {
+		return didplc.Doc{}, stacktrace.Propagate(ErrDIDNotFound, "")
+	}
+
+	opEnum := l[len(l)-1].Operation
+	if opEnum.Tombstone != nil {
+		return didplc.Doc{}, stacktrace.Propagate(ErrDIDGone, "")
+	}
+	return opEnum.AsOperation().Doc(did)
+}
+
+func (plc *plcImpl) OperationLog(ctx context.Context, atHeight TreeVersion, did string) ([]didplc.OpEnum, error) {
+	// GetPlcOpLog - /:did/log - same data as audit log but excludes nullified. just the inner operations
+	// if missing -> returns ErrDIDNotFound
+	// if tombstone -> returns log as normal
+
+	plc.mu.Lock()
+	defer plc.mu.Unlock()
+
+	tree, err := plc.treeProvider.ImmutableTree(atHeight)
+	if err != nil {
+		return nil, stacktrace.Propagate(err, "failed to obtain immutable tree")
+	}
+
+	l, _, err := store.Tree.AuditLog(tree, did, false)
+	if err != nil {
+		return nil, stacktrace.Propagate(err, "")
+	}
+
+	if len(l) == 0 {
+		return nil, stacktrace.Propagate(ErrDIDNotFound, "")
+	}
+
+	return lo.Map(l, func(logEntry didplc.LogEntry, _ int) didplc.OpEnum {
+		return logEntry.Operation
+	}), nil
+}
+
+func (plc *plcImpl) AuditLog(ctx context.Context, atHeight TreeVersion, did string) ([]didplc.LogEntry, error) {
+	// GetPlcAuditLog - /:did/log/audit - full audit log, with nullified
+	// if missing -> returns ErrDIDNotFound
+	// if tombstone -> returns log as normal
+	plc.mu.Lock()
+	defer plc.mu.Unlock()
+
+	tree, err := plc.treeProvider.ImmutableTree(atHeight)
+	if err != nil {
+		return nil, stacktrace.Propagate(err, "failed to obtain immutable tree")
+	}
+
+	l, _, err := store.Tree.AuditLog(tree, did, false)
+	if err != nil {
+		return nil, stacktrace.Propagate(err, "")
+	}
+
+	if len(l) == 0 {
+		return nil, stacktrace.Propagate(ErrDIDNotFound, "")
+	}
+
+	return l, 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?)
+	// if missing -> returns ErrDIDNotFound
+	// if tombstone -> returns tombstone op
+	plc.mu.Lock()
+	defer plc.mu.Unlock()
+
+	tree, err := plc.treeProvider.ImmutableTree(atHeight)
+	if err != nil {
+		return didplc.OpEnum{}, stacktrace.Propagate(err, "failed to obtain immutable tree")
+	}
+
+	l, _, err := store.Tree.AuditLog(tree, did, false)
+	if err != nil {
+		return didplc.OpEnum{}, stacktrace.Propagate(err, "")
+	}
+
+	if len(l) == 0 {
+		return didplc.OpEnum{}, stacktrace.Propagate(ErrDIDNotFound, "")
+	}
+
+	return l[len(l)-1].Operation, nil
+}
+
+func (plc *plcImpl) Data(ctx context.Context, atHeight TreeVersion, did string) (didplc.RegularOp, error) {
+	// GetPlcData - /:did/data - similar to GetLastOp but applies a transformation on the op which normalizes it into a modern op
+	// if missing -> returns ErrDIDNotFound
+	// if tombstone -> returns ErrDIDGone
+	plc.mu.Lock()
+	defer plc.mu.Unlock()
+
+	tree, err := plc.treeProvider.ImmutableTree(atHeight)
+	if err != nil {
+		return didplc.RegularOp{}, stacktrace.Propagate(err, "failed to obtain immutable tree")
+	}
+
+	l, _, err := store.Tree.AuditLog(tree, did, false)
+	if err != nil {
+		return didplc.RegularOp{}, stacktrace.Propagate(err, "")
+	}
+
+	if len(l) == 0 {
+		return didplc.RegularOp{}, stacktrace.Propagate(ErrDIDNotFound, "")
+	}
+
+	opEnum := l[len(l)-1].Operation
+	if opEnum.Tombstone != nil {
+		return didplc.RegularOp{}, stacktrace.Propagate(ErrDIDGone, "")
+	}
+	if opEnum.Regular != nil {
+		return *opEnum.Regular, nil
+	}
+	return *modernizeOp(opEnum.Legacy), nil
+}
+
+func (plc *plcImpl) Export(ctx context.Context, atHeight TreeVersion, after time.Time, count int) ([]didplc.LogEntry, error) {
+	plc.mu.Lock()
+	defer plc.mu.Unlock()
+
+	tree, err := plc.treeProvider.ImmutableTree(atHeight)
+	if err != nil {
+		return nil, stacktrace.Propagate(err, "failed to obtain immutable tree")
+	}
+
+	entries, err := store.Tree.ExportOperations(tree, after, count)
+	return entries, stacktrace.Propagate(err, "")
+}
+
+type inMemoryAuditLogFetcher struct {
+	plc *plcImpl
+}
+
+func (a *inMemoryAuditLogFetcher) AuditLogReverseIterator(atHeight TreeVersion, did string, retErr *error) iter.Seq2[int, didplc.LogEntry] {
+	tree, err := a.plc.treeProvider.ImmutableTree(atHeight)
+	if err != nil {
+		*retErr = stacktrace.Propagate(err, "")
+		return func(yield func(int, didplc.LogEntry) bool) {}
+	}
+
+	return store.Tree.AuditLogReverseIterator(tree, did, retErr)
+}

plc/operation_validator.go

···
+package plc
+
+import (
+	"errors"
+	"iter"
+	"strings"
+	"time"
+
+	"github.com/bluesky-social/indigo/atproto/atcrypto"
+	"github.com/bluesky-social/indigo/atproto/syntax"
+	"github.com/did-method-plc/go-didplc"
+	"github.com/ipfs/go-cid"
+	"github.com/palantir/stacktrace"
+	"github.com/samber/mo"
+)
+
+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]
+}
+
+type V0OperationValidator struct {
+	auditLogFetcher AuditLogFetcher
+}
+
+func NewV0OperationValidator(logFetcher AuditLogFetcher) *V0OperationValidator {
+	return &V0OperationValidator{
+		auditLogFetcher: logFetcher,
+	}
+}
+
+type OperationEffects struct {
+	NullifiedEntriesStartingIndex mo.Option[int]
+	NewLogEntry                   didplc.LogEntry
+	NewOperationCID               cid.Cid // should be equivalent to the CID field inside NewLogEntry, but that's a string and we need the strongly typed Cid sometimes
+	NewOperationIndex             int
+}
+
+// Validate returns the new complete AuditLog that the DID history would assume if validation passes, and an error if it doesn't pass
+func (v *V0OperationValidator) Validate(atHeight TreeVersion, timestamp syntax.Datetime, expectedDid string, opBytes []byte, laxChecking bool) (OperationEffects, error) {
+	opEnum, op, err := unmarshalOp(opBytes)
+	if err != nil {
+		return OperationEffects{}, stacktrace.Propagate(errors.Join(ErrMalformedOperation, err), "")
+	}
+
+	if !op.IsSigned() {
+		return OperationEffects{}, stacktrace.Propagate(ErrOperationNotSigned, "")
+	}
+
+	september29Of2023 := time.Date(2023, time.September, 28, 0, 0, 0, 0, time.UTC)
+	// certain constraints appear to only have been enforced after late September 27, 2023 based on a Sep 29 announcement
+	// https://github.com/did-method-plc/did-method-plc/pull/47 (introduced rate limits and 'disallows create v1s' test)
+	// https://github.com/bluesky-social/atproto/discussions/1632
+	if !laxChecking && opEnum.Legacy != nil && !timestamp.Time().After(september29Of2023) {
+		return OperationEffects{}, stacktrace.Propagate(ErrLegacyOperationNotAllowed, "")
+	}
+
+	if op.IsGenesis() {
+		if opEnum.Tombstone != nil {
+			return OperationEffects{}, stacktrace.Propagate(ErrInvalidOperationSequence, "genesis operation cannot be tombstone")
+		}
+		calcDid, err := op.DID()
+		if err != nil {
+			return OperationEffects{}, stacktrace.Propagate(errors.Join(ErrMalformedOperation, err), "")
+		}
+		if calcDid != expectedDid {
+			return OperationEffects{}, stacktrace.Propagate(ErrDIDMismatch, "")
+		}
+	}
+
+	// Validate operation structure and field constraints
+	if !laxChecking && timestamp.Time().After(september29Of2023) {
+		if err := v.validateOperationConstraints(timestamp.Time(), op); err != nil {
+			return OperationEffects{}, stacktrace.Propagate(err, "")
+		}
+	}
+
+	proposedPrev := op.PrevCIDStr()
+
+	partialLog := make(map[int]didplc.LogEntry)
+	mostRecentOpIndex := -1
+	indexOfPrev := -1
+	var iteratorErr error
+	for entryIdx, entry := range v.auditLogFetcher.AuditLogReverseIterator(atHeight, expectedDid, &iteratorErr) {
+		partialLog[entryIdx] = entry
+		if mostRecentOpIndex == -1 {
+			mostRecentOpIndex = entryIdx
+
+			if proposedPrev == "" {
+				return OperationEffects{}, stacktrace.Propagate(ErrInvalidOperationSequence, "creation operation not allowed as DID already exists")
+			}
+		}
+
+		if entry.CID == proposedPrev {
+			indexOfPrev = entryIdx
+			break
+		}
+	}
+
+	if iteratorErr != nil {
+		return OperationEffects{}, stacktrace.Propagate(iteratorErr, "")
+	}
+
+	nullifiedEntries := []didplc.LogEntry{}
+	nullifiedEntriesStartingIndex := mo.None[int]()
+
+	if mostRecentOpIndex < 0 {
+		// we are expecting a creation op, validate it like so
+		newOperationCID := op.CID()
+		newEntry := didplc.LogEntry{
+			DID:       expectedDid,
+			Operation: opEnum,
+			CID:       newOperationCID.String(),
+			Nullified: false,
+			CreatedAt: timestamp.String(),
+		}
+
+		err = didplc.VerifyOpLog([]didplc.LogEntry{newEntry})
+		if err != nil {
+			err = NewInvalidOperationError(4023, err)
+			return OperationEffects{}, stacktrace.Propagate(err, "invalid operation")
+		}
+	} else if indexOfPrev < 0 {
+		// there are entries in the audit log but none of them has a CID matching prev
+		return OperationEffects{}, stacktrace.Propagate(ErrInvalidPrev, "")
+	} else {
+		// we've found the targeted prev operation
+
+		// 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()) {
+			return OperationEffects{}, stacktrace.Propagate(ErrInvalidOperationSequence, "")
+		}
+
+		// if we are forking history, these are the ops still in the proposed canonical history
+
+		lastOpEntry := partialLog[indexOfPrev]
+		lastOp := lastOpEntry.Operation.AsOperation()
+		lastOpRotationKeys := lastOp.EquivalentRotationKeys()
+		for i := indexOfPrev + 1; i <= mostRecentOpIndex; i++ {
+			nullifiedEntries = append(nullifiedEntries, partialLog[i])
+		}
+		if len(nullifiedEntries) > 0 {
+			nullifiedEntriesStartingIndex = mo.Some(indexOfPrev + 1)
+
+			disputedSignerIdx, err := didplc.VerifySignatureAny(nullifiedEntries[0].Operation.AsOperation(), lastOpRotationKeys)
+			if err != nil {
+				return OperationEffects{}, stacktrace.Propagate(err, "reached invalid internal state")
+			}
+			morePowerfulKeys := lastOpRotationKeys[0:disputedSignerIdx]
+
+			_, err = didplc.VerifySignatureAny(op, morePowerfulKeys)
+			if err != nil {
+				return OperationEffects{}, stacktrace.Propagate(ErrInvalidSignature, "")
+			}
+
+			// 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 {
+				return OperationEffects{}, stacktrace.Propagate(ErrRecoveryWindowExpired, "")
+			}
+		} else {
+			// this does not involve nullification
+			_, err := didplc.VerifySignatureAny(op, lastOpRotationKeys)
+			if err != nil {
+				return OperationEffects{}, stacktrace.Propagate(ErrInvalidSignature, "")
+			}
+		}
+	}
+
+	newOperationCID := op.CID()
+	newEntry := didplc.LogEntry{
+		DID:       expectedDid,
+		Operation: opEnum,
+		CID:       newOperationCID.String(),
+		Nullified: false,
+		CreatedAt: timestamp.String(),
+	}
+
+	// do not enforce rate limits on recovery operations to prevent DDOS by a bad actor
+	if len(nullifiedEntries) == 0 {
+		// (see prior note on september27Of2023)
+		if !laxChecking && timestamp.Time().After(september29Of2023) {
+			err = v.EnforceOpsRateLimit(atHeight, expectedDid, timestamp.Time())
+			if err != nil {
+				return OperationEffects{}, stacktrace.Propagate(err, "")
+			}
+		}
+	}
+
+	return OperationEffects{
+		NullifiedEntriesStartingIndex: nullifiedEntriesStartingIndex,
+		NewLogEntry:                   newEntry,
+		NewOperationCID:               newOperationCID,
+		NewOperationIndex:             mostRecentOpIndex + 1,
+	}, nil
+}
+
+// Constants for validation limits (matching TypeScript implementation)
+const (
+	MaxOpBytes            = 4000
+	MaxAkaEntries         = 10
+	MaxAkaLength          = 258
+	MaxRotationEntries    = 10 // the spec suggests this should be 5 but the Typescript implementation uses 10
+	MaxServiceEntries     = 10
+	MaxServiceTypeLength  = 256
+	MaxServiceEndpointLen = 512
+	MaxVmEntries          = 10
+	MaxIdLength           = 32
+	MaxDidKeyLength       = 256
+)
+
+// Rate limiting constants (matching TypeScript implementation)
+const (
+	HourLimit = 10
+	DayLimit  = 30
+	WeekLimit = 100
+)
+
+// EnforceOpsRateLimit is ported from the TypeScript enforceOpsRateLimit function, adapted to not require fetching the entire log
+func (v *V0OperationValidator) EnforceOpsRateLimit(atHeight TreeVersion, did string, newOperationTimestamp time.Time) error {
+	hourAgo := newOperationTimestamp.Add(-time.Hour)
+	dayAgo := newOperationTimestamp.Add(-24 * time.Hour)
+	weekAgo := newOperationTimestamp.Add(-7 * 24 * time.Hour)
+
+	var withinHour, withinDay, withinWeek int
+	var err error
+	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?)
+			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()
+
+		if opTime.Before(weekAgo) {
+			// operations are always ordered by timestamp, and we're iterating from newest to oldest
+			// if we're already looking at operations over a week ago,
+			// there's no way we'll ever increase withinHour, withinDay or withinWeek
+			return nil
+		}
+
+		if opTime.After(weekAgo) {
+			withinWeek++
+			if withinWeek >= WeekLimit {
+				return stacktrace.Propagate(ErrRateLimitExceeded, "too many operations within last week (max %d)", WeekLimit)
+			}
+		}
+		if opTime.After(dayAgo) {
+			withinDay++
+			if withinDay >= DayLimit {
+				return stacktrace.Propagate(ErrRateLimitExceeded, "too many operations within last day (max %d)", DayLimit)
+			}
+		}
+		if opTime.After(hourAgo) {
+			withinHour++
+			if withinHour >= HourLimit {
+				return stacktrace.Propagate(ErrRateLimitExceeded, "too many operations within last hour (max %d)", HourLimit)
+			}
+		}
+	}
+	return stacktrace.Propagate(err, "")
+}
+
+// EnforceOpsRateLimit checks whether a slice of log entries exceeds rate limits
+// This method is ported from the TypeScript enforceOpsRateLimit function
+func EnforceOpsRateLimit(ops []didplc.LogEntry) error {
+	now := time.Now()
+	hourAgo := now.Add(-time.Hour)
+	dayAgo := now.Add(-24 * time.Hour)
+	weekAgo := now.Add(-7 * 24 * time.Hour)
+
+	var withinHour, withinDay, withinWeek int
+
+	for _, op := range ops {
+		// Parse the CreatedAt timestamp string
+		// The CreatedAt field is stored as a string in ISO 8601 format
+		opDatetime, err := syntax.ParseDatetime(op.CreatedAt)
+		if err != nil {
+			// If parsing fails, skip this operation for rate limiting
+			continue
+		}
+		opTime := opDatetime.Time()
+
+		if opTime.After(weekAgo) {
+			withinWeek++
+			if withinWeek >= WeekLimit {
+				return stacktrace.Propagate(ErrRateLimitExceeded, "too many operations within last week (max %d)", WeekLimit)
+			}
+		}
+		if opTime.After(dayAgo) {
+			withinDay++
+			if withinDay >= DayLimit {
+				return stacktrace.Propagate(ErrRateLimitExceeded, "too many operations within last day (max %d)", DayLimit)
+			}
+		}
+		if opTime.After(hourAgo) {
+			withinHour++
+			if withinHour >= HourLimit {
+				return stacktrace.Propagate(ErrRateLimitExceeded, "too many operations within last hour (max %d)", HourLimit)
+			}
+		}
+	}
+
+	return nil
+}
+
+func (v *V0OperationValidator) validateOperationConstraints(createdAt time.Time, op didplc.Operation) error {
+	// Check operation size
+	opBytes := op.SignedCBORBytes()
+	if len(opBytes) > MaxOpBytes {
+		return stacktrace.Propagate(ErrOperationTooLarge, "operation too large (%d bytes maximum, got %d)", MaxOpBytes, len(opBytes))
+	}
+
+	// Handle tombstone operations (no additional constraints needed)
+	if tombstone, ok := op.(*didplc.TombstoneOp); ok {
+		if tombstone.Prev == "" {
+			return stacktrace.Propagate(ErrInvalidPrev, "missing previous in tombstone operation")
+		}
+		return nil
+	}
+
+	// Handle regular operations
+	if regular, ok := op.(*didplc.RegularOp); ok {
+		return stacktrace.Propagate(v.validateRegularOpConstraints(createdAt, regular), "")
+	}
+
+	// Handle legacy operations (creation only)
+	if legacy, ok := op.(*didplc.LegacyOp); ok {
+		return stacktrace.Propagate(v.validateLegacyOpConstraints(createdAt, legacy), "")
+	}
+
+	return stacktrace.Propagate(ErrMalformedOperation, "unknown operation type")
+}
+
+func (v *V0OperationValidator) validateLegacyOpConstraints(createdAt time.Time, op *didplc.LegacyOp) error {
+	if !op.IsGenesis() {
+		return stacktrace.Propagate(ErrLegacyOperationNotAllowed, "legacy format only allowed for genesis operations")
+	}
+
+	// normalize the operation then use the regular validation
+	return stacktrace.Propagate(v.validateRegularOpConstraints(createdAt, modernizeOp(op)), "")
+}
+
+func (v *V0OperationValidator) validateRegularOpConstraints(createdAt time.Time, op *didplc.RegularOp) error {
+	// Validate type
+	if op.Type != "plc_operation" {
+		return stacktrace.Propagate(ErrMalformedOperation, "invalid operation type: %s", op.Type)
+	}
+
+	// Validate alsoKnownAs
+	if len(op.AlsoKnownAs) > MaxAkaEntries {
+		return stacktrace.Propagate(ErrMaxFieldLengthExceeded, "too many alsoKnownAs entries (max %d)", MaxAkaEntries)
+	}
+
+	// Check for duplicate alsoKnownAs and length limits
+	seenAka := make(map[string]bool)
+	for _, aka := range op.AlsoKnownAs {
+		if len(aka) > MaxAkaLength {
+			return stacktrace.Propagate(ErrMaxFieldLengthExceeded, "alsoKnownAs entry too long (max %d): %s", MaxAkaLength, aka)
+		}
+		if seenAka[aka] {
+			return stacktrace.Propagate(ErrDuplicateFields, "duplicate alsoKnownAs entry: %s", aka)
+		}
+		seenAka[aka] = true
+	}
+
+	// Validate rotationKeys
+	if len(op.RotationKeys) == 0 {
+		// the typescript implementation doesn't appear to check this at first sight,
+		// but the spec says "must include least 1 key and at most 5 keys, with no duplication"
+		return stacktrace.Propagate(ErrMalformedOperationField, "missing rotation keys")
+	}
+	if len(op.RotationKeys) > MaxRotationEntries {
+		return stacktrace.Propagate(ErrMaxFieldLengthExceeded, "too many rotationKey entries (max %d)", MaxRotationEntries)
+	}
+
+	//seenKeys := make(map[string]struct{})
+	for _, key := range op.RotationKeys {
+		parsedKey, err := atcrypto.ParsePublicDIDKey(key)
+		if err != nil {
+			return stacktrace.Propagate(ErrMalformedOperationField, "invalid rotationKey: %s", key)
+		}
+		// the typescript implementation doesn't appear to check this at first sight,
+		// but the spec says "must include least 1 key and at most 5 keys, with no duplication"
+		_ = parsedKey
+		// as somewhat expected, we had to relax this check:
+		// CID bafyreigpavgvxvba3b3mkj2tfoqcmubxh2576cvipkx2stmv5bnskxjacq (did:plc:z4cu2w6uedmhnrjhkmv2ajsq) has a duplicate rotationKey
+		// see also https://github.com/did-method-plc/did-method-plc/issues/26 for more examples
+		/*dk := parsedKey.DIDKey()
+		if _, present := seenKeys[dk]; present {
+			return stacktrace.Propagate(ErrDuplicateFields, "duplicate rotationKey: %s", key)
+		}
+		seenKeys[dk] = struct{}{}*/
+	}
+
+	// Validate services
+	if len(op.Services) > MaxServiceEntries {
+		return stacktrace.Propagate(ErrMaxFieldLengthExceeded, "too many service entries (max %d)", MaxServiceEntries)
+	}
+
+	for id, service := range op.Services {
+		if len(id) > MaxIdLength {
+			return stacktrace.Propagate(ErrMaxFieldLengthExceeded, "service id too long (max %d): %s", MaxIdLength, id)
+		}
+		if len(service.Type) > MaxServiceTypeLength {
+			return stacktrace.Propagate(ErrMaxFieldLengthExceeded, "service type too long (max %d): %s", MaxServiceTypeLength, service.Type)
+		}
+		if len(service.Endpoint) > MaxServiceEndpointLen {
+			return stacktrace.Propagate(ErrMaxFieldLengthExceeded, "service endpoint too long (max %d)", MaxServiceEndpointLen)
+		}
+	}
+
+	// Validate verificationMethods
+	// some of these constraints appear to only have been enforced after the start of June 2025, we'll be more lenient and enforce from July onwards only
+	// (https://github.com/did-method-plc/did-method-plc/pull/101)
+	july2025 := time.Date(2025, time.July, 1, 0, 0, 0, 0, time.UTC)
+	if createdAt.After(july2025) && len(op.VerificationMethods) > MaxVmEntries {
+		return stacktrace.Propagate(ErrMaxFieldLengthExceeded, "too many verificationMethod entries (max %d)", MaxVmEntries)
+	}
+
+	for id, key := range op.VerificationMethods {
+		if len(id) > MaxIdLength {
+			return stacktrace.Propagate(ErrMaxFieldLengthExceeded, "verificationMethod id too long (max %d): %s", MaxIdLength, id)
+		}
+		if !createdAt.After(july2025) {
+			continue
+		}
+		if len(key) > MaxDidKeyLength {
+			return stacktrace.Propagate(ErrMaxFieldLengthExceeded, "verificationMethod key too long (max %d): %s", MaxDidKeyLength, key)
+		}
+		if _, err := atcrypto.ParsePublicDIDKey(key); err != nil {
+			return stacktrace.Propagate(ErrMalformedOperationField, "invalid verificationMethod key: %s", key)
+		}
+	}
+
+	return nil
+}
+
+func ensureAtprotoPrefix(str string) string {
+	if strings.HasPrefix(str, "at://") {
+		return str
+	}
+	str = strings.TrimPrefix(str, "http://")
+	str = strings.TrimPrefix(str, "https://")
+	return "at://" + str
+}
+
+func ensureHttpPrefix(str string) string {
+	if strings.HasPrefix(str, "http://") || strings.HasPrefix(str, "https://") {
+		return str
+	}
+	return "https://" + str
+}

plc/plc.go

···
+package plc
+
+import (
+	"context"
+	"errors"
+	"time"
+
+	"github.com/bluesky-social/indigo/atproto/syntax"
+	"github.com/did-method-plc/go-didplc"
+	"github.com/ipfs/go-cid"
+)
+
+var ErrDIDNotFound = errors.New("DID not found")
+var ErrDIDGone = errors.New("DID deactivated")
+
+type TreeVersion struct {
+	workingHeight   bool
+	committedHeight bool
+	specificHeight  int64
+}
+
+func (v TreeVersion) IsMutable() bool {
+	return v.workingHeight
+}
+
+func (v TreeVersion) IsCommitted() bool {
+	return v.committedHeight
+}
+
+func (v TreeVersion) SpecificVersion() (int64, bool) {
+	return v.specificHeight, !v.workingHeight && !v.committedHeight
+}
+
+var WorkingTreeVersion = TreeVersion{
+	workingHeight: true,
+}
+
+var CommittedTreeVersion = TreeVersion{
+	committedHeight: true,
+}
+
+func SpecificTreeVersion(height int64) TreeVersion {
+	return TreeVersion{
+		specificHeight: height,
+	}
+}
+
+type OperationValidator interface {
+	Validate(atHeight TreeVersion, timestamp syntax.Datetime, expectedDid string, opBytes []byte, allowLegacy bool) (OperationEffects, error)
+}
+
+type PLC interface {
+	ReadPLC
+	WritePLC
+}
+
+type ReadPLC interface {
+	ValidateOperation(ctx context.Context, atHeight TreeVersion, at time.Time, did string, opBytes []byte) error
+	Resolve(ctx context.Context, atHeight TreeVersion, did string) (didplc.Doc, error)
+	OperationLog(ctx context.Context, atHeight TreeVersion, did string) ([]didplc.OpEnum, error)
+	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)
+}
+
+type WritePLC interface {
+	ExecuteOperation(ctx context.Context, timestamp time.Time, did string, opBytes []byte) (cid.Cid, error)
+}

plc/plc_test.go

···
+package plc_test
+
+import (
+	"encoding/json"
+	"testing"
+	"time"
+
+	"github.com/bluesky-social/indigo/atproto/syntax"
+	"github.com/did-method-plc/go-didplc"
+	"github.com/samber/lo"
+	"github.com/stretchr/testify/require"
+	"tangled.org/gbl08ma/didplcbft/plc"
+)
+
+func TestPLC(t *testing.T) {
+	type operationToPerform struct {
+		DID           string
+		Operation     string
+		ApplyAt       syntax.Datetime
+		ExpectFailure bool
+	}
+
+	testDID := "did:plc:uyauirpjzk6le4ygqzatcwnq"
+
+	var operations = []operationToPerform{
+		{
+			DID: testDID,
+			Operation: `
+			{
+				"sig": "v7O8dkLUv0UVHs8BX3DXUpy60V0AjljDR14LfGN5mDsqY__JVjpzMWdIaCaRt2KLQq8uoQxHHFjyz4jS906SpQ",
+				"prev": "bafyreifgafcel2okxszhgbugieyvtmfig2gtf3dgqoh5fvdh3nlh6ncv6q",
+				"type": "plc_operation",
+				"services": {
+					"atproto_pds": {
+					"type": "AtprotoPersonalDataServer",
+					"endpoint": "https://at.tny.im"
+					}
+				},
+				"alsoKnownAs": [
+					"at://pds.labeler.tny.im"
+				],
+				"rotationKeys": [
+					"did:key:zQ3shhguVfzmkfgXHzrnSeDxzbAvw7NjiVUcu2nmkeiQUrZUM"
+				],
+				"verificationMethods": {
+					"atproto": "did:key:zQ3shsHRci5EP9nr7dzsy5QkzTbmm8uJBXbXdghbLc8JAqogb"
+				}
+			}`,
+			ApplyAt:       syntax.Datetime("2025-09-19T19:38:16.480Z"),
+			ExpectFailure: true,
+		},
+		{
+			DID: testDID,
+			Operation: `
+			{
+				"sig": "JICl9boFJK12rmBbnuKLHdV51f_CMsrsmWUrgu17DDwtsqSiSazidWA_RZbJplYNr34bTwXyY7kkJ7oJHsbOjQ",
+				"prev": null,
+				"type": "plc_operation",
+				"services": {
+					"atproto_pds": {
+					"type": "AtprotoPersonalDataServer",
+					"endpoint": "https://at.tny.im"
+					}
+				},
+				"alsoKnownAs": [
+					"at://pdslabeler.at.tny.im"
+				],
+				"rotationKeys": [
+					"did:key:zQ3shhguVfzmkfgXHzrnSeDxzbAvw7NjiVUcu2nmkeiQUrZUM"
+				],
+				"verificationMethods": {
+					"atproto": "did:key:zQ3shsHRci5EP9nr7dzsy5QkzTbmm8uJBXbXdghbLc8JAqogb"
+				}
+			}`,
+			ApplyAt: syntax.Datetime("2025-09-19T19:38:16.480Z"),
+		},
+		{
+			DID: testDID,
+			Operation: `
+			{
+				"sig": "v7O8dkLUv0UVHs8BX3DXUpy60V0AjljDR14LfGN5mDsqY__JVjpzMWdIaCaRt2KLQq8uoQxHHFjyz4jS906SpQ",
+				"prev": "bafyreifgafcel2okxszhgbugieyvtmfig2gtf3dgqoh5fvdh3nlh6ncv6q",
+				"type": "plc_operation",
+				"services": {
+					"atproto_pds": {
+					"type": "AtprotoPersonalDataServer",
+					"endpoint": "https://at.tny.im"
+					}
+				},
+				"alsoKnownAs": [
+					"at://pds.labeler.tny.im"
+				],
+				"rotationKeys": [
+					"did:key:zQ3shhguVfzmkfgXHzrnSeDxzbAvw7NjiVUcu2nmkeiQUrZUM"
+				],
+				"verificationMethods": {
+					"atproto": "did:key:zQ3shsHRci5EP9nr7dzsy5QkzTbmm8uJBXbXdghbLc8JAqogb"
+				}
+			}`,
+			ExpectFailure: false,
+			ApplyAt:       syntax.Datetime("2025-09-19T19:41:10.132Z"),
+		},
+		{
+			DID: testDID,
+			Operation: `
+			{
+				"sig": "RFrHbpN5fjdTnPCaXGN5eF_bkz2fRORVisAYu1a2YTh7G4fF9UERjtetJyEXPovjmFapFu-CEoBjuCcIboTztg",
+				"prev": "bafyreia6ewwkwjgly6dijfepaq2ey6zximodbtqqi5f6fyugli3cxohn5m",
+				"type": "plc_operation",
+				"services": {
+					"atproto_pds": {
+						"type": "AtprotoPersonalDataServer",
+						"endpoint": "https://at.tny.im"
+					},
+					"atproto_labeler": {
+						"type": "AtprotoLabeler",
+						"endpoint": "https://pds.labeler.tny.im"
+					}
+				},
+				"alsoKnownAs": [
+					"at://pds.labeler.tny.im"
+				],
+				"rotationKeys": [
+					"did:key:zQ3shhguVfzmkfgXHzrnSeDxzbAvw7NjiVUcu2nmkeiQUrZUM"
+				],
+				"verificationMethods": {
+					"atproto": "did:key:zQ3shsHRci5EP9nr7dzsy5QkzTbmm8uJBXbXdghbLc8JAqogb",
+					"atproto_label": "did:key:zQ3shZ5WhBQGvBUg5z7a2NJ11698KQk9skaGr2YzJiVsXYzi9"
+				}
+			}`,
+			ExpectFailure: false,
+			ApplyAt:       syntax.Datetime("2025-09-19T22:32:52.503Z"),
+		},
+	}
+
+	ctx := t.Context()
+
+	treeProvider := NewTestTreeProvider()
+	testPLC := plc.NewPLC(treeProvider)
+
+	tree, err := treeProvider.MutableTree()
+	require.NoError(t, err)
+	_, origVersion, err := tree.SaveVersion()
+	require.NoError(t, err)
+
+	// resolving a unknown DID should return an error
+	_, err = testPLC.Resolve(ctx, plc.WorkingTreeVersion, "did:plc:y5gazb6lrsk3j4riiro62zjn")
+	require.ErrorIs(t, err, plc.ErrDIDNotFound)
+
+	for _, c := range operations {
+		_, err := testPLC.ExecuteOperation(ctx, c.ApplyAt.Time(), c.DID, []byte(c.Operation))
+		if c.ExpectFailure {
+			require.Error(t, err)
+		} else {
+			require.NoError(t, err)
+		}
+		_, _, err = tree.SaveVersion()
+		require.NoError(t, err)
+	}
+
+	// now try resolving the DID, should return the document with the latest state
+	doc, err := testPLC.Resolve(ctx, plc.WorkingTreeVersion, testDID)
+	require.NoError(t, err)
+	require.Equal(t, testDID, doc.ID)
+	require.Len(t, doc.Service, 2)
+	require.Equal(t, []string{"at://pds.labeler.tny.im"}, doc.AlsoKnownAs)
+
+	log, err := testPLC.OperationLog(ctx, plc.WorkingTreeVersion, testDID)
+	require.NoError(t, err)
+	require.Len(t, log, 3)
+	require.Equal(t, "bafyreifgafcel2okxszhgbugieyvtmfig2gtf3dgqoh5fvdh3nlh6ncv6q", log[0].AsOperation().CID().String())
+	require.Equal(t, "bafyreia6ewwkwjgly6dijfepaq2ey6zximodbtqqi5f6fyugli3cxohn5m", log[1].AsOperation().CID().String())
+	require.Equal(t, "bafyreigyzl2esgnk7nvav5myvgywbshdmatzthc73iiar7tyeq3xjt47m4", log[2].AsOperation().CID().String())
+
+	log, err = testPLC.OperationLog(ctx, plc.SpecificTreeVersion(origVersion+2), testDID)
+	require.NoError(t, err)
+	require.Len(t, log, 1)
+	require.Equal(t, "bafyreifgafcel2okxszhgbugieyvtmfig2gtf3dgqoh5fvdh3nlh6ncv6q", log[0].AsOperation().CID().String())
+
+	// the DID should still be not found in older versions of the tree
+	_, err = testPLC.Resolve(ctx, plc.SpecificTreeVersion(origVersion), testDID)
+	require.ErrorIs(t, err, plc.ErrDIDNotFound)
+
+	doc, err = testPLC.Resolve(ctx, plc.SpecificTreeVersion(origVersion+4), testDID)
+	require.NoError(t, err)
+
+	export, err := testPLC.Export(ctx, plc.CommittedTreeVersion, time.Time{}, 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, "bafyreia6ewwkwjgly6dijfepaq2ey6zximodbtqqi5f6fyugli3cxohn5m", export[1].Operation.AsOperation().CID().String())
+	require.Equal(t, "bafyreia6ewwkwjgly6dijfepaq2ey6zximodbtqqi5f6fyugli3cxohn5m", export[1].CID)
+	require.Equal(t, "bafyreigyzl2esgnk7nvav5myvgywbshdmatzthc73iiar7tyeq3xjt47m4", export[2].Operation.AsOperation().CID().String())
+	require.Equal(t, "bafyreigyzl2esgnk7nvav5myvgywbshdmatzthc73iiar7tyeq3xjt47m4", export[2].CID)
+
+	// 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)
+	require.NoError(t, err)
+	require.Len(t, export, 1)
+	require.Equal(t, "bafyreia6ewwkwjgly6dijfepaq2ey6zximodbtqqi5f6fyugli3cxohn5m", export[0].CID)
+}
+
+func TestPLCFromRemoteOperations(t *testing.T) {
+	var client didplc.Client
+
+	testDIDs := []string{
+		"did:plc:uyauirpjzk6le4ygqzatcwnq",
+		"did:plc:l37td5yhxl2irrzrgvei4qay",
+		"did:plc:ia76kvnndjutgedggx2ibrem",
+		"did:plc:mn45tewwnse5btfftvd3powc",
+		"did:plc:ragtjsm2j2vknwkz3zp4oxrd",
+		"did:plc:rnpkyqnmsw4ipey6eotbdnnf",
+		"did:plc:syldnchxgxctqcjvkhqprrxz",
+		"did:plc:yk4dd2qkboz2yv6tpubpc6co",
+		//"did:plc:qeikkritllfcxmdtzet2tqcr",
+		"did:plc:pkmfz5soq2swsvbhvjekb36g", // tombstone with nullifications
+	}
+
+	remoteLogs := make([][]didplc.LogEntry, 0, len(testDIDs))
+	for _, testDID := range testDIDs {
+		auditLog, err := client.AuditLog(t.Context(), testDID)
+		require.NoError(t, err)
+
+		remoteLogs = append(remoteLogs, auditLog)
+	}
+
+	ctx := t.Context()
+
+	treeProvider := NewTestTreeProvider()
+	testPLC := plc.NewPLC(treeProvider)
+
+	for _, auditLog := range remoteLogs {
+		for _, logEntry := range auditLog {
+			b, err := json.Marshal(&logEntry.Operation)
+			require.NoError(t, err)
+
+			at := syntax.Datetime(logEntry.CreatedAt).Time()
+
+			err = testPLC.ValidateOperation(ctx, plc.WorkingTreeVersion, at, logEntry.DID, b)
+			require.NoError(t, err)
+
+			_, err = testPLC.ExecuteOperation(ctx, at, logEntry.DID, b)
+			require.NoError(t, err)
+
+			_, err = testPLC.ExecuteOperation(ctx, at, logEntry.DID, b)
+			// committing the same operation twice should never work,
+			// as though even in non-genesis ops the referenced prev will exist,
+			// (and thus could seem like a recovery operation at first glance)
+			// valid recovery operations must be signed by a key with a lower index in the rotationKeys array
+			// than the one which signed the operation to be invalidated
+			require.Error(t, err)
+		}
+	}
+
+	_, newVersion, err := lo.Must(treeProvider.MutableTree()).SaveVersion()
+	require.NoError(t, err)
+
+	for i, testDID := range testDIDs {
+		doc, err := testPLC.Resolve(ctx, plc.SpecificTreeVersion(newVersion), testDID)
+		if testDID == "did:plc:pkmfz5soq2swsvbhvjekb36g" {
+			require.ErrorContains(t, err, "deactivated")
+		} else {
+			require.NoError(t, err)
+			require.Equal(t, testDID, doc.ID)
+		}
+
+		actualLog, err := testPLC.AuditLog(ctx, plc.SpecificTreeVersion(newVersion), testDID)
+		require.NoError(t, err)
+		require.Len(t, actualLog, len(remoteLogs[i]))
+		for j := range actualLog {
+			require.Equal(t, remoteLogs[i][j].DID, actualLog[j].DID)
+			require.Equal(t, remoteLogs[i][j].CID, actualLog[j].CID)
+			require.Equal(t, remoteLogs[i][j].Nullified, actualLog[j].Nullified)
+			require.Equal(t, syntax.Datetime(remoteLogs[i][j].CreatedAt).Time(), syntax.Datetime(actualLog[j].CreatedAt).Time())
+
+			remoteBytes, err := json.Marshal(&remoteLogs[i][j].Operation)
+			require.NoError(t, err)
+
+			actualBytes, err := json.Marshal(&actualLog[j].Operation)
+			require.NoError(t, err)
+
+			require.Equal(t, remoteBytes, actualBytes)
+		}
+	}
+
+	export, err := testPLC.Export(ctx, plc.CommittedTreeVersion, time.Time{}, 0)
+	require.NoError(t, err)
+	require.Len(t, export, 96)
+
+	// ensure entries are sorted correctly
+	last := time.Time{}
+	for _, entry := range export {
+		et, err := syntax.ParseDatetime(entry.CreatedAt)
+		require.NoError(t, err)
+		require.True(t, et.Time().After(last))
+		last = et.Time()
+	}
+}
+
+func TestEnforceOpsRateLimit(t *testing.T) {
+	// Test case 1: Operations within rate limits should pass
+	t.Run("WithinLimits", func(t *testing.T) {
+		now := time.Now()
+		ops := []didplc.LogEntry{
+			{
+				DID:       "did:plc:test1",
+				CreatedAt: now.Add(-30 * time.Minute).Format(time.RFC3339),
+			},
+			{
+				DID:       "did:plc:test1",
+				CreatedAt: now.Add(-45 * time.Minute).Format(time.RFC3339),
+			},
+		}
+
+		err := plc.EnforceOpsRateLimit(ops)
+		require.NoError(t, err)
+	})
+
+	// Test case 2: Exceeding hourly limit should fail
+	t.Run("ExceedHourlyLimit", func(t *testing.T) {
+		now := time.Now()
+		ops := make([]didplc.LogEntry, plc.HourLimit+1)
+		for i := 0; i < len(ops); i++ {
+			ops[i] = didplc.LogEntry{
+				DID:       "did:plc:test2",
+				CreatedAt: now.Add(-time.Duration(i) * time.Minute).Format(time.RFC3339),
+			}
+		}
+
+		err := plc.EnforceOpsRateLimit(ops)
+		require.ErrorContains(t, err, "too many operations within last hour")
+	})
+
+	// Test case 3: Exceeding daily limit should fail
+	t.Run("ExceedDailyLimit", func(t *testing.T) {
+		now := time.Now()
+		ops := make([]didplc.LogEntry, plc.DayLimit+1)
+		for i := 0; i < len(ops); i++ {
+			// Create operations within the last day but over the daily limit
+			ops[i] = didplc.LogEntry{
+				DID:       "did:plc:test3",
+				CreatedAt: now.Add(-time.Duration(i%24) * time.Hour).Format(time.RFC3339),
+			}
+		}
+
+		err := plc.EnforceOpsRateLimit(ops)
+		require.ErrorContains(t, err, "too many operations within last day")
+	})
+
+	// Test case 4: Exceeding weekly limit should fail
+	t.Run("ExceedWeeklyLimit", func(t *testing.T) {
+		now := time.Now()
+		ops := make([]didplc.LogEntry, plc.WeekLimit+1)
+		for i := 0; i < len(ops); i++ {
+			// Create operations within the last week but over the weekly limit
+			ops[i] = didplc.LogEntry{
+				DID:       "did:plc:test4",
+				CreatedAt: now.Add(-time.Duration(i%168) * time.Hour).Format(time.RFC3339),
+			}
+		}
+
+		err := plc.EnforceOpsRateLimit(ops)
+		require.ErrorContains(t, err, "too many operations within last week")
+	})
+
+	// Test case 5: Many operations within day but spread across hours should not exceed hourly limit
+	t.Run("OperationsSpreadAcrossHours", func(t *testing.T) {
+		now := time.Now()
+		// Create 15 operations within the last day (within daily limit of 30)
+		// but spread across 2+ hours so no single hour exceeds the limit of 10
+		ops := make([]didplc.LogEntry, 15)
+		for i := 0; i < 15; i++ {
+			// First 8 operations in the last 30 minutes
+			if i < 8 {
+				ops[i] = didplc.LogEntry{
+					DID:       "did:plc:test6",
+					CreatedAt: now.Add(-time.Duration(i) * time.Minute).Format(time.RFC3339),
+				}
+			} else {
+				// Next 7 operations spread across 2+ hours ago
+				ops[i] = didplc.LogEntry{
+					DID:       "did:plc:test6",
+					CreatedAt: now.Add(-(2*time.Hour + time.Duration(i-8)*time.Minute)).Format(time.RFC3339),
+				}
+			}
+		}
+
+		err := plc.EnforceOpsRateLimit(ops)
+		require.NoError(t, err)
+	})
+}

plc/testutil_test.go

···
+package plc_test
+
+import (
+	"github.com/cosmos/iavl"
+	dbm "github.com/cosmos/iavl/db"
+	"github.com/palantir/stacktrace"
+	"tangled.org/gbl08ma/didplcbft/plc"
+	"tangled.org/gbl08ma/didplcbft/store"
+)
+
+type testTreeProvider struct {
+	tree *iavl.MutableTree
+}
+
+func NewTestTreeProvider() *testTreeProvider {
+	return &testTreeProvider{
+		tree: iavl.NewMutableTree(dbm.NewMemDB(), 128, false, iavl.NewNopLogger()),
+	}
+}
+
+func (t *testTreeProvider) ImmutableTree(version plc.TreeVersion) (store.PossiblyMutableTree, error) {
+	if version.IsMutable() {
+		return store.AdaptMutableTree(t.tree), nil
+	}
+	var v int64
+	if version.IsCommitted() {
+		var err error
+		v, err = t.tree.GetLatestVersion()
+		if err != nil {
+			return nil, stacktrace.Propagate(err, "")
+		}
+	} else {
+		var ok bool
+		v, ok = version.SpecificVersion()
+		if !ok {
+			return nil, stacktrace.NewError("unsupported TreeVersion")
+		}
+	}
+
+	it, err := t.tree.GetImmutable(v)
+	return store.AdaptImmutableTree(it), stacktrace.Propagate(err, "")
+}
+
+func (t *testTreeProvider) MutableTree() (*iavl.MutableTree, error) {
+	return t.tree, nil
+}

plc/util.go

···
+package plc
+
+import (
+	"encoding/json"
+
+	"github.com/did-method-plc/go-didplc"
+	"github.com/palantir/stacktrace"
+	"github.com/samber/lo"
+)
+
+func unmarshalOp(opBytes []byte) (didplc.OpEnum, didplc.Operation, error) {
+	var opEnum didplc.OpEnum
+
+	err := json.Unmarshal(opBytes, &opEnum)
+	if err != nil {
+		return didplc.OpEnum{}, nil, stacktrace.Propagate(err, "")
+	}
+
+	op := opEnum.AsOperation()
+	if op == nil {
+		return didplc.OpEnum{}, nil, stacktrace.NewError("unknown operation type")
+	}
+	return opEnum, op, nil
+}
+
+func modernizeOp(op *didplc.LegacyOp) *didplc.RegularOp {
+	return &didplc.RegularOp{
+		Type: "plc_operation",
+		VerificationMethods: map[string]string{
+			"atproto": op.SigningKey,
+		},
+		RotationKeys: lo.Uniq([]string{op.RecoveryKey, op.SigningKey}),
+		AlsoKnownAs:  []string{ensureAtprotoPrefix(op.Service)},
+		Services: map[string]didplc.OpService{
+			"atproto_pds": {
+				Type:     "AtprotoPersonalDataServer",
+				Endpoint: ensureHttpPrefix(op.Service),
+			},
+		},
+		Prev: op.Prev,
+		Sig:  op.Sig,
+	}
+}

plc/validation_errors.go

···
+package plc
+
+import "errors"
+
+type invalidOperationError struct {
+	inner       error
+	checkTxCode uint32
+}
+
+func (i *invalidOperationError) Error() string {
+	return i.inner.Error()
+}
+
+func (i *invalidOperationError) Unwrap() error {
+	return i.inner
+}
+
+func (i *invalidOperationError) Is(err error) bool {
+	var e *invalidOperationError
+	return errors.As(err, &e)
+}
+
+func NewInvalidOperationError(checkTxCode uint32, inner error) error {
+	return &invalidOperationError{
+		inner:       inner,
+		checkTxCode: checkTxCode,
+	}
+}
+
+func IsInvalidOperationError(err error) bool {
+	return errors.Is(err, &invalidOperationError{})
+}
+
+func InvalidOperationErrorCode(err error) (uint32, bool) {
+	var e *invalidOperationError
+	if errors.As(err, &e) {
+		return e.checkTxCode, true
+	}
+	return 0, false
+}
+
+var ErrMalformedOperation = NewInvalidOperationError(4010, errors.New("malformed operation"))
+var ErrMalformedOperationField = NewInvalidOperationError(4011, errors.New("malformed operation field"))
+var ErrRateLimitExceeded = NewInvalidOperationError(4012, errors.New("rate limit exceeded"))
+var ErrOperationNotSigned = NewInvalidOperationError(4013, errors.New("operation not signed"))
+var ErrInvalidSignature = NewInvalidOperationError(4014, errors.New("invalid signature on operation"))
+var ErrLegacyOperationNotAllowed = NewInvalidOperationError(4015, errors.New("legacy operation format not allowed"))
+var ErrInvalidOperationSequence = NewInvalidOperationError(4016, errors.New("invalid operation sequence"))
+var ErrDIDMismatch = NewInvalidOperationError(4017, errors.New("genesis operation does not match expected DID"))
+var ErrInvalidPrev = NewInvalidOperationError(4018, errors.New("operation references invalid prev"))
+var ErrOperationTooLarge = NewInvalidOperationError(4019, errors.New("operation too large"))
+var ErrMaxFieldLengthExceeded = NewInvalidOperationError(4020, errors.New("maximum field length exceeded"))
+var ErrDuplicateFields = NewInvalidOperationError(4021, errors.New("duplicate field data"))
+var ErrRecoveryWindowExpired = NewInvalidOperationError(4022, errors.New("recovery window has passed"))

start-testnet.sh

···
+#!/bin/sh
+
+# Default to 4 nodes if no argument provided
+NUM_NODES="${1:-4}"
+
+# Validate input
+if ! echo "$NUM_NODES" | grep -qE '^[0-9]+$'; then
+    echo "Error: Number of nodes must be a positive integer"
+    echo "Usage: $0 [number_of_nodes]"
+    echo "Example: $0 7"
+    exit 1
+fi
+
+if [ "$NUM_NODES" -lt 1 ]; then
+    echo "Error: Number of nodes must be at least 1"
+    exit 1
+fi
+
+echo "Starting testnet with $NUM_NODES nodes (preserving existing data)..."
+
+# Check if testnet directory exists and has the expected number of nodes
+if [ ! -d "testnet/node0" ]; then
+    echo "Error: No existing testnet found. Run ./startfresh-testnet.sh first to create the testnet."
+    exit 1
+fi
+
+# Count existing nodes
+existing_nodes=0
+for i in $(seq 0 99); do
+    if [ -d "testnet/node$i" ]; then
+        existing_nodes=$((existing_nodes + 1))
+    else
+        break
+    fi
+done
+
+if [ "$NUM_NODES" -gt "$existing_nodes" ]; then
+    echo "Error: Requested $NUM_NODES nodes but only $existing_nodes nodes exist in testnet/"
+    echo "Run ./startfresh-testnet.sh $NUM_NODES to create additional nodes."
+    exit 1
+fi
+
+echo "Found $existing_nodes existing nodes, starting first $NUM_NODES nodes..."
+
+# Check if binary exists, build if needed
+if [ ! -f "./didplcbft" ]; then
+    echo "Binary not found, building didplcbft..."
+    go build -trimpath
+fi
+
+# Array to store background process IDs
+pids=""
+
+# Cleanup function to kill all background processes
+cleanup() {
+    echo ""
+    echo "Shutting down all nodes..."
+    
+    # Kill all background processes
+    for pid in $pids; do
+        if kill -0 "$pid" 2>/dev/null; then
+            echo "  Stopping node process $pid..."
+            kill "$pid" 2>/dev/null
+        fi
+    done
+    
+    # Clean up temporary fifo files
+    for i in $(seq 0 99); do
+        rm -f "/tmp/didplcbft-node$i-stdout" "/tmp/didplcbft-node$i-stderr" 2>/dev/null
+    done
+    
+    # Wait for all processes to terminate
+    wait $pids 2>/dev/null
+    
+    echo "All nodes stopped."
+    exit 0
+}
+
+# Set up signal traps
+trap cleanup INT TERM EXIT
+
+# Launch all nodes in parallel
+echo "Launching $NUM_NODES nodes in parallel..."
+
+for i in $(seq 0 $((NUM_NODES - 1))); do
+    if [ -d "testnet/node$i" ]; then
+        echo "  Starting node$i..."
+        mkfifo "/tmp/didplcbft-node$i-stdout" 2>/dev/null || true
+        mkfifo "/tmp/didplcbft-node$i-stderr" 2>/dev/null || true
+        
+        # Start sed processes to prefix output
+        sed "s/^/[node$i-stdout] /" < "/tmp/didplcbft-node$i-stdout" &
+        sed "s/^/[node$i-stderr] /" < "/tmp/didplcbft-node$i-stderr" &
+        
+        # Start the didplcbft process with redirected output
+        ./didplcbft --data-dir "testnet/node$i" > "/tmp/didplcbft-node$i-stdout" 2> "/tmp/didplcbft-node$i-stderr" &
+        pid=$!
+        pids="$pids $pid"
+        echo "    PID: $pid"
+    else
+        echo "  Warning: node$i directory not found, skipping..."
+    fi
+done
+
+echo ""
+echo "All $NUM_NODES nodes are now running."
+echo "Press Ctrl+C to stop all nodes."
+echo ""
+
+# Wait for all background processes
+wait $pids
+
+# If we reach here, all processes have terminated normally
+echo "All nodes have terminated."

startfresh-testnet.sh

···
+#!/bin/sh
+
+# Default to 4 nodes if no argument provided
+NUM_NODES="${1:-4}"
+
+# Validate input
+if ! echo "$NUM_NODES" | grep -qE '^[0-9]+$'; then
+    echo "Error: Number of nodes must be a positive integer"
+    echo "Usage: $0 [number_of_nodes]"
+    echo "Example: $0 7"
+    exit 1
+fi
+
+if [ "$NUM_NODES" -lt 1 ]; then
+    echo "Error: Number of nodes must be at least 1"
+    exit 1
+fi
+
+echo "Setting up testnet with $NUM_NODES nodes..."
+
+# Build the binary
+echo "Building didplcbft binary..."
+go build -trimpath
+
+# Clean up existing testnet data
+echo "Cleaning up existing testnet data..."
+rm -r testnet/node*
+
+# Generate testnet with specified number of nodes
+echo "Generating testnet configuration for $NUM_NODES nodes..."
+go run github.com/cometbft/cometbft/cmd/cometbft@v0.38.19 testnet --v "$((NUM_NODES - 1))" --n 1 --starting-ip-address 127.67.67.1 --config ./testnet/baseconfig.toml --o ./testnet
+
+# Adjust RPC and P2P listen addresses for each node
+echo "Configuring RPC and P2P addresses for $NUM_NODES nodes..."
+
+for i in $(seq 0 $((NUM_NODES - 1))); do
+    # Calculate RPC port (starting from 26100)
+    rpc_port=$((26100 + i))
+    
+    # Calculate P2P IP address (127.67.67.1 + node_index)
+    p2p_ip="127.67.67.$((1 + i))"
+    
+    echo "  Configuring node$i (RPC: $rpc_port, P2P: $p2p_ip:26656)"
+    
+    # Adjust RPC listen address
+    sed -i "s|^laddr = \"tcp://127.0.0.1:26657\"\$|laddr = \"tcp://127.0.0.1:$rpc_port\"|g" "testnet/node$i/config/config.toml"
+    
+    # Adjust P2P listen address
+    sed -i "s|^laddr = \"tcp://0.0.0.0:26656\"\$|laddr = \"tcp://$p2p_ip:26656\"|g" "testnet/node$i/config/config.toml"
+done
+
+# Configure rpc_servers for the last node (the one that will be started manually)
+last_node=$((NUM_NODES - 1))
+echo "Configuring rpc_servers for node$last_node..."
+
+# Build comma-separated list of RPC addresses for automatically started nodes
+rpc_servers_list=""
+for i in $(seq 0 $((NUM_NODES - 2))); do
+    if [ -n "$rpc_servers_list" ]; then
+        rpc_servers_list="$rpc_servers_list,"
+    fi
+    rpc_port=$((26100 + i))
+    rpc_servers_list="${rpc_servers_list}tcp://127.0.0.1:$rpc_port"
+done
+
+# Replace empty rpc_servers configuration in the last node's config
+echo "  Setting rpc_servers = \"$rpc_servers_list\" for node$last_node"
+sed -i "s|^rpc_servers = \"\"\$|rpc_servers = \"$rpc_servers_list\"|g" "testnet/node$last_node/config/config.toml"
+
+# Enable state sync for the last node (the one that will be started manually)
+echo "  Enabling state sync for node$last_node"
+sed -i '/\[statesync\]/,/enable = false/s/enable = false/enable = true/' "testnet/node$last_node/config/config.toml"
+
+# Array to store background process IDs
+pids=""
+
+# Cleanup function to kill all background processes
+cleanup() {
+    echo ""
+    echo "Shutting down all nodes..."
+    
+    # Kill all background processes
+    for pid in $pids; do
+        if kill -0 "$pid" 2>/dev/null; then
+            echo "  Stopping node process $pid..."
+            kill "$pid" 2>/dev/null
+        fi
+    done
+    
+    # Clean up temporary fifo files
+    for i in $(seq 0 99); do
+        rm -f "/tmp/didplcbft-node$i-stdout" "/tmp/didplcbft-node$i-stderr" 2>/dev/null
+    done
+    
+    # Wait for all processes to terminate
+    wait $pids 2>/dev/null
+    
+    echo "All nodes stopped."
+    exit 0
+}
+
+# Set up signal traps
+trap cleanup INT TERM EXIT
+
+# Launch all nodes except the last one (for testing later bringup)
+nodes_to_start=$((NUM_NODES - 1))
+echo "Launching $nodes_to_start nodes in parallel..."
+
+for i in $(seq 0 $((nodes_to_start - 1))); do
+    echo "  Starting node$i..."
+    mkfifo "/tmp/didplcbft-node$i-stdout" 2>/dev/null || true
+    mkfifo "/tmp/didplcbft-node$i-stderr" 2>/dev/null || true
+    
+    # Start sed processes to prefix output
+    sed "s/^/[node$i-stdout] /" < "/tmp/didplcbft-node$i-stdout" &
+    sed "s/^/[node$i-stderr] /" < "/tmp/didplcbft-node$i-stderr" &
+    
+    # Start the didplcbft process with redirected output
+    ./didplcbft --data-dir "testnet/node$i" > "/tmp/didplcbft-node$i-stdout" 2> "/tmp/didplcbft-node$i-stderr" &
+    pid=$!
+    pids="$pids $pid"
+    echo "    PID: $pid"
+done
+
+echo ""
+echo "All $nodes_to_start nodes are now running."
+echo "Note: Node $((NUM_NODES - 1)) is not started and can be launched later for testing."
+echo "Press Ctrl+C to stop all running nodes."
+echo ""
+
+# Wait for all background processes
+wait $pids
+
+# If we reach here, all processes have terminated normally
+echo "All nodes have terminated."

startfresh.sh

···
+#!/bin/sh
+rm -r didplcbft-data/
+go build -trimpath
+go run github.com/cometbft/cometbft/cmd/cometbft@v0.38.19 init --home didplcbft-data
+sed -i 's/^create_empty_blocks = true$/create_empty_blocks = false/g' didplcbft-data/config/config.toml
+./didplcbft

store/tree.go

···
+package store
+
+import (
+	"encoding/base32"
+	"encoding/binary"
+	"iter"
+	"slices"
+	"strings"
+	"time"
+
+	"github.com/bluesky-social/indigo/atproto/syntax"
+	"github.com/cosmos/iavl"
+	ics23 "github.com/cosmos/ics23/go"
+	"github.com/did-method-plc/go-didplc"
+	cbornode "github.com/ipfs/go-ipld-cbor"
+	"github.com/palantir/stacktrace"
+	"github.com/polydawn/refmt/obj/atlas"
+	"github.com/samber/lo"
+	"github.com/samber/mo"
+)
+
+var Tree PLCTreeStore = &TreeStore{}
+
+type PLCTreeStore interface {
+	AuditLog(tree PossiblyMutableTree, did string, withProof bool) ([]didplc.LogEntry, *ics23.CommitmentProof, error)
+	AuditLogReverseIterator(tree PossiblyMutableTree, did string, err *error) iter.Seq2[int, didplc.LogEntry]
+	ExportOperations(tree PossiblyMutableTree, after time.Time, count int) ([]didplc.LogEntry, error) // passing a count of zero means unlimited
+	StoreOperation(tree *iavl.MutableTree, entry didplc.LogEntry, newIndex int, nullifyWithIndexEqualOrGreaterThan mo.Option[int]) error
+}
+
+var _ PLCTreeStore = (*TreeStore)(nil)
+
+// TreeStore exists just to groups methods nicely
+type TreeStore struct{}
+
+type PossiblyMutableTree interface {
+	IsMutable() bool
+	Has(key []byte) (bool, error)
+	Get(key []byte) ([]byte, error)
+	GetProof(key []byte) (*ics23.CommitmentProof, error) // won't actually work on mutable trees, but we don't need it to
+	IterateRange(start, end []byte, ascending bool, fn func(key []byte, value []byte) bool) (stopped bool)
+	Set(key []byte, value []byte) (bool, error)
+}
+
+type mutableToUnifiedTree struct {
+	tree *iavl.MutableTree
+}
+
+var _ PossiblyMutableTree = (*mutableToUnifiedTree)(nil)
+
+func AdaptMutableTree(tree *iavl.MutableTree) PossiblyMutableTree {
+	return &mutableToUnifiedTree{
+		tree: tree,
+	}
+}
+
+// IsMutable implements [PossiblyMutableTree].
+func (m *mutableToUnifiedTree) IsMutable() bool {
+	return true
+}
+
+// Has implements [PossiblyMutableTree].
+func (m *mutableToUnifiedTree) Has(key []byte) (bool, error) {
+	return m.tree.Has(key)
+}
+
+// Get implements [PossiblyMutableTree].
+func (m *mutableToUnifiedTree) Get(key []byte) ([]byte, error) {
+	return m.tree.Get(key)
+}
+
+// GetProof implements [PossiblyMutableTree].
+func (m *mutableToUnifiedTree) GetProof(key []byte) (*ics23.CommitmentProof, error) {
+	return nil, stacktrace.NewError("proof calculation not possible over mutable tree")
+}
+
+// Set implements [PossiblyMutableTree].
+func (m *mutableToUnifiedTree) Set(key []byte, value []byte) (bool, error) {
+	return m.tree.Set(key, value)
+}
+
+// IterateRange implements [PossiblyMutableTree].
+func (m *mutableToUnifiedTree) IterateRange(start []byte, end []byte, ascending bool, fn func(key []byte, value []byte) bool) (stopped bool) {
+	// it might look like MutableTree implements IterateRange but it doesn't,
+	// most iteration methods actually come from the embedded ImmutableTree we're not meant to use
+	// (terrible API)
+	itr, err := m.tree.Iterator(start, end, ascending)
+	if err != nil {
+		return false
+	}
+
+	defer itr.Close()
+
+	for ; itr.Valid(); itr.Next() {
+		if fn(itr.Key(), itr.Value()) {
+			return true
+		}
+	}
+	return false
+}
+
+type immutableToUnifiedTree struct {
+	tree *iavl.ImmutableTree
+}
+
+var _ PossiblyMutableTree = (*immutableToUnifiedTree)(nil)
+
+func AdaptImmutableTree(tree *iavl.ImmutableTree) PossiblyMutableTree {
+	return &immutableToUnifiedTree{
+		tree: tree,
+	}
+}
+
+// IsMutable implements [PossiblyMutableTree].
+func (m *immutableToUnifiedTree) IsMutable() bool {
+	return false
+}
+
+// Has implements [PossiblyMutableTree].
+func (i *immutableToUnifiedTree) Has(key []byte) (bool, error) {
+	return i.tree.Has(key)
+}
+
+// Get implements [PossiblyMutableTree].
+func (i *immutableToUnifiedTree) Get(key []byte) ([]byte, error) {
+	return i.tree.Get(key)
+}
+
+// GetProof implements [PossiblyMutableTree].
+func (i *immutableToUnifiedTree) GetProof(key []byte) (*ics23.CommitmentProof, error) {
+	return i.tree.GetProof(key)
+}
+
+// IterateRange implements [PossiblyMutableTree].
+func (i *immutableToUnifiedTree) IterateRange(start []byte, end []byte, ascending bool, fn func(key []byte, value []byte) bool) (stopped bool) {
+	return i.tree.IterateRange(start, end, ascending, fn)
+}
+
+// Set implements [PossiblyMutableTree].
+func (i *immutableToUnifiedTree) Set(key []byte, value []byte) (bool, error) {
+	return false, stacktrace.NewError("set not possible over immutable tree")
+}
+
+func (t *TreeStore) AuditLog(tree PossiblyMutableTree, did string, withProof bool) ([]didplc.LogEntry, *ics23.CommitmentProof, error) {
+	proofs := []*ics23.CommitmentProof{}
+
+	didBytes, err := didToBytes(did)
+	if err != nil {
+		return nil, nil, stacktrace.Propagate(err, "")
+	}
+
+	logKey := marshalDIDLogKey(didBytes)
+
+	has, err := tree.Has(logKey)
+	if err != nil {
+		return nil, nil, stacktrace.Propagate(err, "")
+	}
+
+	var operationKeys [][]byte
+	if has {
+		logOperations, err := tree.Get(logKey)
+		if err != nil {
+			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))
+		}
+	}
+
+	if withProof {
+		proof, err := tree.GetProof(logKey)
+		if err != nil {
+			return nil, nil, stacktrace.Propagate(err, "")
+		}
+		proofs = append(proofs, proof)
+	}
+
+	logEntries := make([]didplc.LogEntry, 0, len(operationKeys))
+	for _, opKey := range operationKeys {
+		operationValue, err := tree.Get(opKey)
+		if err != nil {
+			return nil, nil, stacktrace.Propagate(err, "")
+		}
+
+		if withProof {
+			proof, err := tree.GetProof(opKey)
+			if err != nil {
+				return nil, nil, stacktrace.Propagate(err, "")
+			}
+			proofs = append(proofs, proof)
+		}
+
+		nullified, operation, err := unmarshalOperationValue(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(syntax.AtprotoDatetimeLayout),
+		})
+	}
+
+	var combinedProof *ics23.CommitmentProof
+	if withProof {
+		combinedProof, err = ics23.CombineProofs(proofs)
+		if err != nil {
+			return nil, nil, stacktrace.Propagate(err, "failed to combine proofs")
+		}
+	}
+	return logEntries, combinedProof, nil
+}
+
+func (t *TreeStore) AuditLogReverseIterator(tree PossiblyMutableTree, did string, retErr *error) iter.Seq2[int, didplc.LogEntry] {
+	return func(yield func(int, didplc.LogEntry) bool) {
+		didBytes, err := didToBytes(did)
+		if err != nil {
+			*retErr = stacktrace.Propagate(err, "")
+			return
+		}
+
+		logKey := marshalDIDLogKey(didBytes)
+
+		has, err := tree.Has(logKey)
+		if err != nil {
+			*retErr = stacktrace.Propagate(err, "")
+			return
+		}
+
+		var operationKeys [][]byte
+		if has {
+			logOperations, err := tree.Get(logKey)
+			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 i := len(operationKeys) - 1; i >= 0; i-- {
+			opKey := operationKeys[i]
+			operationValue, err := tree.Get(opKey)
+			if err != nil {
+				*retErr = stacktrace.Propagate(err, "")
+				return
+			}
+
+			nullified, operation, err := unmarshalOperationValue(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(syntax.AtprotoDatetimeLayout),
+			}) {
+				return
+			}
+		}
+	}
+}
+
+func (t *TreeStore) ExportOperations(tree PossiblyMutableTree, after time.Time, count int) ([]didplc.LogEntry, 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))
+	}
+
+	entries := make([]didplc.LogEntry, 0, count)
+	var iterErr error
+	tree.IterateRange(startKey, nil, true, func(operationKey, operationValue []byte) bool {
+		nullified, operation, err := unmarshalOperationValue(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(syntax.AtprotoDatetimeLayout),
+		})
+		return len(entries) == count // this condition being checked here also makes it so that a count of zero means unlimited
+	})
+	if iterErr != nil {
+		return nil, stacktrace.Propagate(iterErr, "ran into an error while iterating")
+	}
+	return entries, nil
+}
+
+func (t *TreeStore) StoreOperation(tree *iavl.MutableTree, entry didplc.LogEntry, newIndex int, nullifyWithIndexEqualOrGreaterThan mo.Option[int]) error {
+	didBytes, err := didToBytes(entry.DID)
+	if err != nil {
+		return stacktrace.Propagate(err, "")
+	}
+
+	logKey := marshalDIDLogKey(didBytes)
+
+	var operationKeys [][]byte
+	logOperations, err := tree.Get(logKey)
+	logOperations = slices.Clone(logOperations)
+	if err != nil {
+		operationKeys = [][]byte{}
+	} else {
+		operationKeys = make([][]byte, 0, len(logOperations)/8)
+		for ts := range slices.Chunk(logOperations, 8) {
+			operationKeys = append(operationKeys, timestampBytesToDIDOperationKey(ts, didBytes))
+		}
+	}
+
+	if nullifyEGt, ok := nullifyWithIndexEqualOrGreaterThan.Get(); ok {
+		for _, opKey := range operationKeys[nullifyEGt:] {
+			operationValue, err := tree.Get(opKey)
+			if err != nil {
+				return stacktrace.Propagate(err, "")
+			}
+			operationValue = slices.Clone(operationValue)
+			operationValue[0] = 1
+
+			_, err = tree.Set(opKey, operationValue)
+			if err != nil {
+				return stacktrace.Propagate(err, "")
+			}
+		}
+	}
+
+	opDatetime, err := syntax.ParseDatetime(entry.CreatedAt)
+	if err != nil {
+		return stacktrace.Propagate(err, "invalid CreatedAt")
+	}
+
+	opKey := marshalOperationKey(opDatetime.Time().Truncate(1*time.Millisecond), didBytes)
+	opValue := marshalOperationValue(entry.Nullified, entry.Operation)
+
+	_, err = tree.Set(opKey, opValue)
+	if err != nil {
+		return stacktrace.Propagate(err, "")
+	}
+
+	logOperations = append(logOperations, opKey[1:9]...)
+	_, err = tree.Set(logKey, logOperations)
+	if err != nil {
+		return stacktrace.Propagate(err, "")
+	}
+
+	return nil
+}
+
+func didToBytes(did string) ([]byte, error) {
+	if !strings.HasPrefix(did, "did:plc:") {
+		return nil, stacktrace.NewError("invalid did:plc")
+	}
+
+	didBytes := make([]byte, 15)
+
+	did = strings.ToUpper(did)
+
+	numWritten, err := base32.StdEncoding.Decode(didBytes, []byte(did[8:]))
+	if err != nil {
+		return nil, stacktrace.Propagate(err, "invalid did:plc")
+	}
+	if numWritten != 15 {
+		return nil, stacktrace.NewError("invalid did:plc")
+	}
+
+	return didBytes, nil
+}
+
+func bytesToDID(didBytes []byte) (string, error) {
+	did := "did:plc:" + strings.ToLower(base32.StdEncoding.EncodeToString(didBytes))
+	if len(did) != 8+24 {
+		return "", stacktrace.NewError("invalid did:plc")
+	}
+	return did, nil
+}
+
+func marshalDIDLogKey(didBytes []byte) []byte {
+	key := make([]byte, 1+15)
+	key[0] = 'l'
+	copy(key[1:], didBytes)
+	return key
+}
+
+func timestampBytesToDIDOperationKey(timestamp []byte, didBytes []byte) []byte {
+	key := make([]byte, 1+8+15)
+	key[0] = 'o'
+	copy(key[1:9], timestamp)
+	copy(key[9:], didBytes)
+	return key
+}
+
+func marshalOperationKey(createdAt time.Time, didBytes []byte) []byte {
+	key := make([]byte, 1+8+15)
+	key[0] = 'o'
+	binary.BigEndian.PutUint64(key[1:], uint64(createdAt.UTC().UnixNano()))
+	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 marshalOperationValue(nullified bool, operation didplc.OpEnum) []byte {
+	o := []byte{lo.Ternary[byte](nullified, 1, 0)}
+	o = append(o, operation.AsOperation().SignedCBORBytes()...)
+	return o
+}
+
+func unmarshalOperationValue(value []byte) (bool, didplc.OpEnum, error) {
+	nullified := value[0] != 0
+	var opEnum didplc.OpEnum
+	err := cbornode.DecodeInto(value[1:], &opEnum)
+	if err != nil {
+		return false, didplc.OpEnum{}, stacktrace.Propagate(err, "")
+	}
+	return nullified, opEnum, nil
+}
+
+func init() {
+	cbornode.RegisterCborType(atlas.BuildEntry(didplc.OpEnum{}).
+		Transform().
+		TransformMarshal(atlas.MakeMarshalTransformFunc(
+			func(o didplc.OpEnum) (interface{}, error) {
+				if o.Regular != nil {
+					return o.Regular, nil
+				} else if o.Legacy != nil {
+					return o.Legacy, nil
+				} else if o.Tombstone != nil {
+					return o.Tombstone, nil
+				}
+				return nil, stacktrace.NewError("invalid OpEnum")
+			})).
+		TransformUnmarshal(atlas.MakeUnmarshalTransformFunc(
+			func(x map[string]any) (didplc.OpEnum, error) {
+				typ, ok := x["type"]
+				if !ok {
+					return didplc.OpEnum{}, stacktrace.NewError("did not find expected operation 'type' field")
+				}
+
+				// this is so stupid but oh well - maybe one day the entire thing will be upgraded to a less stupid cbor encoder
+				b, err := cbornode.DumpObject(x)
+				if err != nil {
+					return didplc.OpEnum{}, stacktrace.Propagate(err, "")
+				}
+
+				switch typ {
+				case "plc_operation":
+					o := &didplc.RegularOp{}
+					err = cbornode.DecodeInto(b, &o)
+					return didplc.OpEnum{
+						Regular: o,
+					}, stacktrace.Propagate(err, "")
+				case "create":
+					o := &didplc.LegacyOp{}
+					err = cbornode.DecodeInto(b, &o)
+					return didplc.OpEnum{
+						Legacy: o,
+					}, stacktrace.Propagate(err, "")
+				case "plc_tombstone":
+					o := &didplc.TombstoneOp{}
+					err = cbornode.DecodeInto(b, &o)
+					return didplc.OpEnum{
+						Tombstone: o,
+					}, stacktrace.Propagate(err, "")
+				default:
+					return didplc.OpEnum{}, stacktrace.NewError("unexpected operation type: %s", typ)
+				}
+			})).
+		Complete())
+}