···
+
// courtesy of the best 🐇 mary
+
// https://github.com/mary-ext/boat/blob/trunk/src/views/identity/plc-oplogs.tsx
+
import { IndexedEntry, Service } from "@atcute/did-plc";
+
export type DiffEntry =
+
type: "identity_created";
+
rotationKeys: string[];
+
verificationMethods: Record<string, string>;
+
services: Record<string, { type: string; endpoint: string }>;
+
type: "identity_tombstoned";
+
type: "rotation_key_added";
+
type: "rotation_key_removed";
+
type: "verification_method_added";
+
type: "verification_method_removed";
+
type: "verification_method_changed";
+
prev_method_key: string;
+
next_method_key: string;
+
type: "handle_removed";
+
type: "handle_changed";
+
service_endpoint: string;
+
type: "service_removed";
+
service_endpoint: string;
+
type: "service_changed";
+
prev_service_type: string;
+
next_service_type: string;
+
prev_service_endpoint: string;
+
next_service_endpoint: string;
+
export const createOperationHistory = (entries: IndexedEntry[]): DiffEntry[] => {
+
const history: DiffEntry[] = [];
+
for (let idx = 0, len = entries.length; idx < len; idx++) {
+
const entry = entries[idx];
+
const op = entry.operation;
+
if (op.type === "create") {
+
type: "identity_created",
+
nullified: entry.nullified,
+
rotationKeys: [op.recoveryKey, op.signingKey],
+
verificationMethods: { atproto: op.signingKey },
+
alsoKnownAs: [`at://${op.handle}`],
+
type: "AtprotoPersonalDataServer",
+
} else if (op.type === "plc_operation") {
+
const prevOp = findLastMatching(entries, (entry) => !entry.nullified, idx - 1)?.operation;
+
let oldRotationKeys: string[];
+
let oldVerificationMethods: Record<string, string>;
+
let oldAlsoKnownAs: string[];
+
let oldServices: Record<string, Service>;
+
type: "identity_created",
+
nullified: entry.nullified,
+
rotationKeys: op.rotationKeys,
+
verificationMethods: op.verificationMethods,
+
alsoKnownAs: op.alsoKnownAs,
+
} else if (prevOp.type === "create") {
+
oldRotationKeys = [prevOp.recoveryKey, prevOp.signingKey];
+
oldVerificationMethods = { atproto: prevOp.signingKey };
+
oldAlsoKnownAs = [`at://${prevOp.handle}`];
+
type: "AtprotoPersonalDataServer",
+
endpoint: prevOp.service,
+
} else if (prevOp.type === "plc_operation") {
+
oldRotationKeys = prevOp.rotationKeys;
+
oldVerificationMethods = prevOp.verificationMethods;
+
oldAlsoKnownAs = prevOp.alsoKnownAs;
+
oldServices = prevOp.services;
+
// Check for rotation key changes
+
const additions = difference(op.rotationKeys, oldRotationKeys);
+
const removals = difference(oldRotationKeys, op.rotationKeys);
+
for (const key of additions) {
+
type: "rotation_key_added",
+
nullified: entry.nullified,
+
for (const key of removals) {
+
type: "rotation_key_removed",
+
nullified: entry.nullified,
+
// Check for verification method changes
+
for (const id in op.verificationMethods) {
+
if (!(id in oldVerificationMethods)) {
+
type: "verification_method_added",
+
nullified: entry.nullified,
+
method_key: op.verificationMethods[id],
+
} else if (op.verificationMethods[id] !== oldVerificationMethods[id]) {
+
type: "verification_method_changed",
+
nullified: entry.nullified,
+
prev_method_key: oldVerificationMethods[id],
+
next_method_key: op.verificationMethods[id],
+
for (const id in oldVerificationMethods) {
+
if (!(id in op.verificationMethods)) {
+
type: "verification_method_removed",
+
nullified: entry.nullified,
+
method_key: oldVerificationMethods[id],
+
// Check for handle changes
+
if (op.alsoKnownAs.length === 1 && oldAlsoKnownAs.length === 1) {
+
if (op.alsoKnownAs[0] !== oldAlsoKnownAs[0]) {
+
type: "handle_changed",
+
nullified: entry.nullified,
+
prev_handle: oldAlsoKnownAs[0],
+
next_handle: op.alsoKnownAs[0],
+
const additions = difference(op.alsoKnownAs, oldAlsoKnownAs);
+
const removals = difference(oldAlsoKnownAs, op.alsoKnownAs);
+
for (const handle of additions) {
+
nullified: entry.nullified,
+
for (const handle of removals) {
+
type: "handle_removed",
+
nullified: entry.nullified,
+
// Check for service changes
+
for (const id in op.services) {
+
if (!(id in oldServices)) {
+
nullified: entry.nullified,
+
service_type: op.services[id].type,
+
service_endpoint: op.services[id].endpoint,
+
} else if (!dequal(op.services[id], oldServices[id])) {
+
type: "service_changed",
+
nullified: entry.nullified,
+
prev_service_type: oldServices[id].type,
+
next_service_type: op.services[id].type,
+
prev_service_endpoint: oldServices[id].endpoint,
+
next_service_endpoint: op.services[id].endpoint,
+
for (const id in oldServices) {
+
if (!(id in op.services)) {
+
type: "service_removed",
+
nullified: entry.nullified,
+
service_type: oldServices[id].type,
+
service_endpoint: oldServices[id].endpoint,
+
} else if (op.type === "plc_tombstone") {
+
type: "identity_tombstoned",
+
nullified: entry.nullified,
+
function findLastMatching<T, S extends T>(
+
predicate: (item: T) => item is S,
+
function findLastMatching<T>(
+
predicate: (item: T) => boolean,
+
function findLastMatching<T>(
+
predicate: (item: T) => boolean,
+
start: number = arr.length - 1,
+
for (let i = start, v: any; i >= 0; i--) {
+
if (predicate((v = arr[i]))) {
+
function difference<T>(a: readonly T[], b: readonly T[]): T[] {
+
const set = new Set(b);
+
return a.filter((value) => !set.has(value));
+
const dequal = (a: any, b: any): boolean => {
+
if (a && b && (ctor = a.constructor) === b.constructor) {
+
if ((len = a.length) === b.length) {
+
if (!dequal(a[len], b[len])) {
+
} else if (!ctor || ctor === Object) {
+
if (!(ctor in b) || !dequal(a[ctor], b[ctor])) {
+
return Object.keys(b).length === len;
+
return a !== a && b !== b;
+
export const groupBy = <K, T>(items: T[], keyFn: (item: T, index: number) => K): Map<K, T[]> => {
+
const map = new Map<K, T[]>();
+
for (let idx = 0, len = items.length; idx < len; idx++) {
+
const val = items[idx];
+
const key = keyFn(val, idx);
+
const list = map.get(key);
+
if (list !== undefined) {
pdsls.dev
juli.ee