refactor: separate append/dispute concerns

src/views/identity/plc-applicator/page.tsx

···
 import type { CredentialManager } from '@atcute/client';
 import type { ComAtprotoIdentityGetRecommendedDidCredentials } from '@atcute/client/lexicons';
 import type { P256PrivateKey, Secp256k1PrivateKey } from '@atcute/crypto';
-import type { DidDocument } from '@atcute/identity';
+import type { CompatibleOperation, IndexedEntry, IndexedEntryWithSigner } from '@atcute/did-plc';
+import type { Did, DidDocument } from '@atcute/identity';
 
 import { UpdatePayload } from '~/api/types/plc';
 
···
 
 import { Wizard } from '~/components/wizard';
 
-import type { DetailedPlcEntry } from './plc-utils';
-
 import Step1_HandleInput from './steps/step1_handle-input';
 import Step2_PdsAuthentication from './steps/step2_pds-authentication';
 import Step2_PrivateKeyInput from './steps/step2_private-key-input';
···
 
 export interface PlcInformation {
 	didDoc: DidDocument;
-	logs: DetailedPlcEntry[];
+	logs: IndexedEntryWithSigner[];
 }
 
 export interface PdsSigningMethod {
···
 export interface PrivateKeySigningMethod {
 	type: 'private_key';
 	keypair: Keypair;
-	didPublicKey: string;
+	didPublicKey: Did<'key'>;
 }
 
 export type SigningMethod = PdsSigningMethod | PrivateKeySigningMethod;
···
 	Step4_PayloadInput: {
 		info: PlcInformation;
 		method: SigningMethod;
-		base: DetailedPlcEntry;
+		base: IndexedEntry<CompatibleOperation>;
 	};
 
 	Step5_PdsConfirmation: {
 		info: PlcInformation;
 		method: PdsSigningMethod;
-		base: DetailedPlcEntry;
+		base: IndexedEntry<CompatibleOperation>;
 		payload: UpdatePayload;
 	};
 	Step5_PrivateKeyConfirmation: {
 		info: PlcInformation;
 		method: PrivateKeySigningMethod;
-		base: DetailedPlcEntry;
+		base: IndexedEntry<CompatibleOperation>;
 		payload: UpdatePayload;
 	};
 

src/views/identity/plc-applicator/plc-utils.ts

···
-import * as CBOR from '@atcute/cbor';
-import { verifySigWithDidKey } from '@atcute/crypto';
 import type { IndexedEntry } from '@atcute/did-plc';
-import { fromBase64Url } from '@atcute/multibase';
 
 import { UpdatePayload } from '~/api/types/plc';
-import { UnwrapArray } from '~/api/utils/types';
 
 import { assert } from '~/lib/utils/invariant';
 
···
 
 	assert(false);
 };
-
-export const getPlcKeying = async (logs: IndexedEntry[]) => {
-	logs = logs.filter((entry) => !entry.nullified);
-
-	const length = logs.length;
-	const promises = logs.map(async (entry, idx) => {
-		const operation = entry.operation;
-		if (operation.type === 'plc_tombstone') {
-			return;
-		}
-
-		// If it's not the last entry, check if the next entry ahead of this one
-		// was made within the last 72 hours.
-		if (idx !== length - 1) {
-			const next = logs[idx + 1]!;
-			const date = new Date(next.createdAt);
-			const diff = Date.now() - date.getTime();
-
-			if (diff / (1_000 * 60 * 60) > 72) {
-				return;
-			}
-		}
-
-		/** keys that potentially signed this operation */
-		let signers: `did:key:${string}`[] | undefined;
-		if (operation.prev === null) {
-			if (operation.type === 'create') {
-				signers = [operation.recoveryKey, operation.signingKey];
-			} else if (operation.type === 'plc_operation') {
-				signers = operation.rotationKeys;
-			}
-		} else {
-			const prev = logs[idx - 1];
-			assert(prev !== undefined, `missing previous entry from ${entry.createdAt}`);
-			assert(prev.cid === operation.prev, `prev cid mismatch on ${entry.createdAt}`);
-
-			const prevOp = prev.operation;
-
-			if (prevOp.type === 'create') {
-				signers = [prevOp.recoveryKey, prevOp.signingKey];
-			} else if (prevOp.type === 'plc_operation') {
-				signers = prevOp.rotationKeys;
-			}
-		}
-
-		assert(signers !== undefined, `no signers found for ${entry.createdAt}`);
-
-		const opBytes = CBOR.encode({ ...operation, sig: undefined });
-		const sigBytes = fromBase64Url(operation.sig);
-
-		/** key that signed this operation */
-		let signedBy: string | undefined;
-		for (const key of signers) {
-			const valid = await verifySigWithDidKey(key, sigBytes, opBytes);
-			if (valid) {
-				signedBy = key;
-				break;
-			}
-		}
-
-		assert(signedBy !== undefined, `no valid signer for ${entry.createdAt}`);
-
-		return {
-			...entry,
-			signers,
-			signedBy,
-		};
-	});
-
-	const fulfilled = await Promise.all(promises);
-	return fulfilled.filter((entry) => entry !== undefined);
-};
-
-type DetailedEntries = Awaited<ReturnType<typeof getPlcKeying>>;
-export type DetailedPlcEntry = UnwrapArray<DetailedEntries>;
-
-export const getCurrentSignersFromEntry = (entry: IndexedEntry): string[] => {
-	const operation = entry.operation;
-
-	/** keys that can sign the next operation */
-	let nextSigners: string[] | undefined;
-	if (operation.type === 'create') {
-		nextSigners = [operation.recoveryKey, operation.signingKey];
-	} else if (operation.type === 'plc_operation') {
-		nextSigners = operation.rotationKeys;
-	}
-
-	assert(nextSigners !== undefined, `no signers found for ${entry.createdAt}`);
-	return nextSigners;
-};

src/views/identity/plc-applicator/steps/step1_handle-input.tsx

···
 import { createSignal } from 'solid-js';
 
 import { XRPCError } from '@atcute/client';
+import { processIndexedEntryLog } from '@atcute/did-plc';
 import { type Did, isHandle, isPlcDid } from '@atcute/identity';
 
 import { getDidDocument } from '~/api/queries/did-doc';
···
 import { Stage, StageActions, StageErrorView, WizardStepProps } from '~/components/wizard';
 
 import { type PlcInformation, PlcApplicatorConstraints } from '../page';
-import { getPlcKeying } from '../plc-utils';
 
 type Method = 'pds' | 'key';
 
···
 			}
 
 			const [didDoc, logs] = await Promise.all([getDidDocument({ did }), getPlcAuditLogs({ did })]);
+			const { canonical } = await processIndexedEntryLog(did, logs);
 
 			return {
-				didDoc,
-				logs: await getPlcKeying(logs),
+				didDoc: didDoc,
+				logs: canonical,
 			};
 		},
 		onMutate() {

src/views/identity/plc-applicator/steps/step3_operation-select.tsx

···
-import { createMemo, createSignal } from 'solid-js';
+import { createMemo, createSignal, Show } from 'solid-js';
+
+import {
+	type CompatibleOperation,
+	type DisputeCandidate,
+	getDisputeCandidates,
+	type IndexedEntryWithSigner,
+	normalizeOp,
+} from '@atcute/did-plc';
+import type { Did } from '@atcute/identity';
 
 import Button from '~/components/inputs/button';
 import SelectInput from '~/components/inputs/select-input';
 import { Stage, StageActions, StageErrorView, WizardStepProps } from '~/components/wizard';
 
 import { PlcApplicatorConstraints } from '../page';
-import { getCurrentSignersFromEntry } from '../plc-utils';
+import RadioInput from '~/components/inputs/radio-input';
 
 const Step3_OperationSelect = ({
 	data,
···
 	onNext,
 }: WizardStepProps<PlcApplicatorConstraints, 'Step3_OperationSelect'>) => {
 	const [error, setError] = createSignal<string>();
-	const [selectedCid, setSelectedCid] = createSignal<string>();
 
-	const options = createMemo(() => {
-		const signingMethod = data.method;
-		const logs = data.info.logs;
+	const [type, setType] = createSignal<'append' | 'dispute'>();
+	const [cid, setCid] = createSignal<string>();
 
-		let ownKey: string | undefined;
-		if (signingMethod.type === 'pds') {
-			ownKey = signingMethod.recommendedDidDoc.rotationKeys?.at(-1);
-		} else if (signingMethod.type === 'private_key') {
-			ownKey = signingMethod.didPublicKey;
-		}
-
-		if (ownKey === undefined) {
-			return [];
-		}
-
-		const length = logs.length;
-		const items = logs.map((entry, idx) => {
-			const signers = getCurrentSignersFromEntry(entry);
-			const last = idx === length - 1;
-
-			let enabled = signers.includes(ownKey!);
-
-			// If we're showing older operations for forking/nullification,
-			// check to see that our key has priority over the signer.
-			if (enabled && !last) {
-				if (signingMethod.type === 'pds') {
-					// `signPlcOperation` will always grab the last op
-					enabled = false;
-				} else {
-					const holderKey = logs[idx + 1].signedBy;
+	const canAppend = createMemo(() => {
+		const signing = data.method;
 
-					const holderPriority = signers.indexOf(holderKey);
-					const ownPriority = signers.indexOf(ownKey);
+		const lastOp = data.info.logs.at(-1) as IndexedEntryWithSigner<CompatibleOperation>;
+		const { rotationKeys } = normalizeOp(lastOp.operation);
 
-					enabled = ownPriority < holderPriority;
+		switch (signing.type) {
+			case 'pds': {
+				const key = signing.recommendedDidDoc.rotationKeys?.at(-1) as Did<'key'> | undefined;
+				if (!key) {
+					return false;
 				}
+
+				return rotationKeys.includes(key);
 			}
+			case 'private_key': {
+				return rotationKeys.includes(signing.didPublicKey);
+			}
+		}
+	});
 
-			return {
-				value: entry.cid,
-				label: `${entry.createdAt} (by ${entry.signedBy})`,
-				disabled: !enabled,
-			};
-		});
+	const disputes = createMemo((): DisputeCandidate[] => {
+		const signing = data.method;
 
-		return items.reverse();
+		switch (signing.type) {
+			case 'pds': {
+				// signPlcOperation always grabs the last operation, so we can't make
+				// any dispute attempts.
+				return [];
+			}
+			case 'private_key': {
+				return getDisputeCandidates(data.info.logs, signing.didPublicKey);
+			}
+		}
 	});
 
 	return (
 		<Stage
-			title="Select which operation to use as foundation"
+			title="What do you want to do?"
 			onSubmit={() => {
 				setError();
 
-				const cid = selectedCid();
-				const entry = data.info.logs.find((entry) => entry.cid === cid);
+				const $type = type();
+				const $cid = cid();
 
-				if (!entry) {
-					setError(`Can't find CID ${cid}`);
-					return;
-				}
+				switch ($type) {
+					case 'append': {
+						const lastOp = data.info.logs.at(-1) as IndexedEntryWithSigner<CompatibleOperation>;
+
+						onNext('Step4_PayloadInput', {
+							info: data.info,
+							method: data.method,
+							base: lastOp,
+						});
+
+						break;
+					}
+					case 'dispute': {
+						const entry = disputes().find((entry) => entry.base.cid === $cid);
+						if (!entry) {
+							setError(`Can't find dispute entry for ${$cid}`);
+							return;
+						}
+
+						onNext('Step4_PayloadInput', {
+							info: data.info,
+							method: data.method,
+							base: entry.base,
+						});
 
-				const operation = entry.operation;
-				if (operation.type !== 'plc_operation' && operation.type === 'create') {
-					setError(`Expected operation to be of type "plc_operation" or "create"`);
-					return;
+						break;
+					}
 				}
-
-				onNext('Step4_PayloadInput', {
-					info: data.info,
-					method: data.method,
-					base: entry,
-				});
 			}}
 		>
-			<SelectInput
-				label="Base operation"
-				blurb="Some operations can't be used as a base if the rotation key does not have the privilege for nullification, or if it is not listed."
+			<RadioInput
+				label="I want to..."
 				required
-				value={selectedCid()}
-				autofocus={isActive()}
-				options={[{ value: '', label: `Select an operation...` }, ...options()]}
-				onChange={setSelectedCid}
+				value={type()}
+				options={[
+					{
+						value: 'append',
+						label: `Append an operation`,
+						disabled: !canAppend(),
+					},
+					{
+						value: 'dispute',
+						label: `Dispute an existing operation`,
+						disabled: disputes().length === 0,
+					},
+				]}
+				onChange={setType}
 			/>
 
+			<Show when={type() === 'dispute'}>
+				<SelectInput
+					label="Dispute operation"
+					blurb="Select an operation to dispute."
+					required
+					value={cid()}
+					autofocus={isActive()}
+					options={[
+						{ value: '', label: `Select an operation...` },
+						...disputes().map((entry) => ({
+							value: entry.base.cid,
+							label: `${entry.base.cid} ➔ ${entry.disputed.cid} (by ${entry.disputed.signedBy})`,
+						})),
+					]}
+					onChange={setCid}
+				/>
+			</Show>
+
+			<Show when={!canAppend() && disputes().length === 0}>
+				<p class="whitespace-pre-wrap text-[0.8125rem] font-medium leading-5 text-red-800">
+					This rotation key can't be used.
+				</p>
+			</Show>
+
 			<StageErrorView error={error()} />
 
 			<StageActions hidden={!isActive()}>
···
 				<Button variant="secondary" onClick={onPrevious}>
 					Previous
 				</Button>
-				<Button type="submit">Next</Button>
+				<Button type="submit" disabled={type() === undefined}>
+					Next
+				</Button>
 			</StageActions>
 		</Stage>
 	);