Misc cleanups

README.md

···
   - ...but export only works with timestamps (sequence-based export and websocket-based export is not implemented)
 - Validation of operations (hopefully it's foolproof enough - needs revising, strengthening... and nullification might not be as simple as I made it out to be?)
 - Snapshot-based sync for quickly bringing replicas up to date
+- An initial, not very well tested, version of the "authoritative import" that gradually brings in operations from the official plc.directory
 
 ## What's yet to be implemented
 
-- Actually syncing with the authoritative source, plc.directory (I am in the middle of this, and I am not liking how many doubts I have about how to approach it)
+- Actually syncing with the authoritative source, plc.directory (in progress - fetching from the official directory is mostly implemented as indicated above; submitting blockchain happenings to the official directory is yet to be implemented)
 - Spam/abuse prevention (typical blockchains do this with transaction fees and some lesser known ones - e.g. Nano - use proof of work, but this is not a cryptocurrency and PoW is a bit ewww)
 - A process for nodes to become validators. Unless everyone agreed that it's best if the set of validators is centralized. I mean, it's not worse than the current state of plc.directory while still allowing people to easily have their own local synced mirror through the magic of CometBFT...
 - Testing, testing, testing, validation, validation, validation...
···
 
 You need to install Go, in case the go.mod and multiple *.go files didn't make it obvious.
 
-To run a single node, you want to use `startfresh.sh`. To run multiple nodes, there's `startfresh-testnet.sh` but note that you'll have to go into the config.toml of every node **except one**, and add
-
-```
-[plc]
-laddr = ""
-```
-
-to prevent the PLC API server from coming up on those nodes (since by default it'd try listening on the same port that's already used by one of the other replicas, and fail to launch).
+To run a single node, you want to use `startfresh.sh`. To run multiple nodes, there's `startfresh-testnet.sh`. Note that using the created config files, only the first node will serve the PLC API.
 
 The PLC API server listens on `127.0.0.1:28080` by default and other fun facts you could learn from reading config.go. There are other ports that the server listens on, one that exposes the CometBFT RPC API, and also the P2P ports for communication between the nodes.
 

abciapp/execution.go

···
 	"time"
 
 	abcitypes "github.com/cometbft/cometbft/abci/types"
+	cbornode "github.com/ipfs/go-ipld-cbor"
 	"github.com/palantir/stacktrace"
 	"github.com/samber/lo"
-	"tangled.org/gbl08ma/didplcbft/store"
 )
 
 // InitChain implements [types.Application].
···
 func (d *DIDPLCApplication) PrepareProposal(ctx context.Context, req *abcitypes.RequestPrepareProposal) (*abcitypes.ResponsePrepareProposal, error) {
 	defer d.tree.Rollback()
 
+	if req.Height == 2 {
+		tx := Transaction[SetAuthoritativePlcArguments]{
+			Action: TransactionActionSetAuthoritativePlc,
+			Arguments: SetAuthoritativePlcArguments{
+				PLCURL:        "https://plc.directory",
+				RestartImport: true,
+			},
+		}
+
+		out, err := cbornode.DumpObject(tx)
+		if err != nil {
+			return nil, stacktrace.Propagate(err, "")
+		}
+
+		req.Txs = append(req.Txs, out)
+	}
+
 	st := time.Now()
 	acceptedTx := make([][]byte, 0, len(req.Txs))
 	toProcess := req.Txs
···
 				return nil, stacktrace.Propagate(err, "")
 			}
 
-			if result.isAuthoritativeImportTransaction {
-				// this type of transaction is not meant to appear in the mempool,
-				// but maybe it's not impossible that a non-compliant node could have gossiped it to us?
-				// (not sure if CometBFT checks transactions coming from other peers against CheckTx)
-				continue
-			}
-
 			if result.Code == 0 {
 				acceptedTx = append(acceptedTx, tx)
 			} else {
···
 
 	if err == nil && len(maybeTx) != 0 {
 		totalSize := lo.SumBy(acceptedTx, func(tx []byte) int { return len(tx) })
-		// 4K safety margin
+		// 4 KB safety margin
 		if totalSize+len(maybeTx) < int(req.MaxTxBytes)-4096 {
 			// we have space to fit the import transaction
 
···
 		return &abcitypes.ResponseProcessProposal{Status: abcitypes.ResponseProcessProposal_REJECT}, nil
 	}
 
-	if req.Height == 1 {
-		tree, err := d.MutableTree()
-		if err != nil {
-			return nil, stacktrace.Propagate(err, "")
-		}
-
-		err = store.Tree.SetAuthoritativePLC(tree, "https://plc.directory")
-		if err != nil {
-			return nil, stacktrace.Propagate(err, "")
-		}
-	}
-
 	// if we return early, ensure we don't use incomplete results where we haven't voted ACCEPT
 	d.lastProcessedProposalHash = nil
 	d.lastProcessedProposalExecTxResults = nil
···
 
 	txResults := make([]*processResult, len(req.Txs))
 	for i, tx := range req.Txs {
-		result, err := processTx(ctx, d.transactionProcessorDependencies(), tx, req.Time, true)
+		result, action, processor, err := beginProcessTx(tx)
 		if err != nil {
 			return nil, stacktrace.Propagate(err, "")
 		}
+		if result.Code == 0 {
+			if action == TransactionActionAuthoritativeImport && i != len(req.Txs)-1 {
+				// if an Authoritative Import transaction is present on the block, it must be the last one
+				return &abcitypes.ResponseProcessProposal{Status: abcitypes.ResponseProcessProposal_REJECT}, nil
+			}
+
+			result, err = finishProcessTx(ctx, d.transactionProcessorDependencies(), processor, tx, req.Time, true)
+			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
-		}
-
-		if result.isAuthoritativeImportTransaction && i != len(req.Txs)-1 {
-			// if an Authoritative Import transaction is present on the block, it must be the last one
 			return &abcitypes.ResponseProcessProposal{Status: abcitypes.ResponseProcessProposal_REJECT}, nil
 		}
 

abciapp/mempool.go

···
 
 // CheckTx implements [types.Application].
 func (d *DIDPLCApplication) CheckTx(ctx context.Context, req *abcitypes.RequestCheckTx) (*abcitypes.ResponseCheckTx, error) {
-	result, err := processTx(ctx, d.transactionProcessorDependencies(), req.Tx, time.Now(), false)
+	result, action, processor, err := beginProcessTx(req.Tx)
 	if err != nil {
 		return nil, stacktrace.Propagate(err, "")
 	}
-	if result.isAuthoritativeImportTransaction {
-		// this type of transaction is meant to be included only by validator nodes
-		return &abcitypes.ResponseCheckTx{
-			Code: 4002,
-			Info: "AuthoritativeImport transactions can only be introduced by validator nodes",
-		}, nil
+	if result.Code == 0 {
+		if action == TransactionActionAuthoritativeImport {
+			// this type of transaction is meant to be included only by validator nodes
+			return &abcitypes.ResponseCheckTx{
+				Code: 4002,
+				Info: "AuthoritativeImport transactions can only be introduced by validator nodes",
+			}, nil
+		}
+
+		result, err = finishProcessTx(ctx, d.transactionProcessorDependencies(), processor, req.Tx, time.Now(), false)
+		if err != nil {
+			return nil, stacktrace.Propagate(err, "")
+		}
 	}
+
 	return &abcitypes.ResponseCheckTx{
 		Code:      result.Code,
 		Data:      result.Data,

abciapp/tx.go

···
 }
 
 type processResult struct {
-	isAuthoritativeImportTransaction bool
-	commitSideEffects                []func()
+	commitSideEffects []func()
 
 	Code      uint32
 	Data      []byte
···
 	}
 }
 
-func processTx(ctx context.Context, deps TransactionProcessorDependencies, txBytes []byte, atTime time.Time, execute bool) (*processResult, error) {
+func beginProcessTx(txBytes []byte) (*processResult, TransactionAction, TransactionProcessor, error) {
 	if !IsTransactionSanitized(txBytes) {
 		return &processResult{
 			Code: 4000,
 			Info: "Transaction bytes do not follow canonical serialization format",
-		}, nil
+		}, "", nil, nil
 	}
 	var v map[string]interface{}
 	err := cbornode.DecodeInto(txBytes, &v)
···
 		return &processResult{
 			Code: 4001,
 			Info: "Invalid transaction",
-		}, nil
+		}, "", nil, nil
 	}
 	actionInterface, ok := v["action"]
 	if !ok {
 		return &processResult{
 			Code: 4001,
 			Info: "Unknown transaction action",
-		}, nil
+		}, "", nil, nil
 	}
-	action, ok := actionInterface.(string)
+	actionString, ok := actionInterface.(string)
 	if !ok {
 		return &processResult{
 			Code: 4001,
 			Info: "Unknown transaction action",
-		}, nil
+		}, "", nil, nil
 	}
 
-	processor, ok := knownActions[TransactionAction(action)]
+	action := TransactionAction(actionString)
+
+	processor, ok := knownActions[action]
 	if !ok {
 		return &processResult{
 			Code: 4001,
 			Info: "Unknown transaction action",
-		}, nil
+		}, "", nil, nil
 	}
 
+	return &processResult{}, action, processor, nil
+}
+
+func finishProcessTx(ctx context.Context, deps TransactionProcessorDependencies, processor TransactionProcessor, txBytes []byte, atTime time.Time, execute bool) (*processResult, error) {
 	result, err := processor(ctx, deps, txBytes, atTime, execute)
 	return result, stacktrace.Propagate(err, "")
 }
+
+func processTx(ctx context.Context, deps TransactionProcessorDependencies, txBytes []byte, atTime time.Time, execute bool) (*processResult, error) {
+	result, _, processor, err := beginProcessTx(txBytes)
+	if err != nil {
+		return nil, stacktrace.Propagate(err, "")
+	}
+	if result.Code != 0 {
+		return result, nil
+	}
+
+	result, err = finishProcessTx(ctx, deps, processor, txBytes, atTime, execute)
+	return result, stacktrace.Propagate(err, "")
+}

abciapp/tx_import.go

···
 	}
 
 	return &processResult{
-		isAuthoritativeImportTransaction: true,
 		commitSideEffects: []func(){
 			func() {
 				aoc.dropSeqBelowOrEqual(newCursor)

startfresh-testnet.sh

···
     
     # 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"
+
+    if [ "$i" -ne 0 ]; then
+        echo -e "\n[plc]\nladdr = \"\"" >> "testnet/node$i/config/config.toml"
+    fi
 done
 
 # Configure rpc_servers for the last node (the one that will be started manually)