@atcute/did-plc 0.1.7 → 0.3.0

package/lib/typedefs.ts

@@ -42,10 +42,8 @@ const _unsignedLegacyCreateOperation = v.object({
 	prev: v.null(),
 	signingKey: didKeyString,
 	recoveryKey: didKeyString,
-	handle: v.string().assert((input) => input.length <= 256, `handle too long (max 256 characters)`),
-	service: v
-		.string()
-		.assert((input) => input.length <= 512, `service endpoint too long (max 512 characters)`),
+	handle: v.string(),
+	service: v.string(),
 }) satisfies v.Type<t.UnsignedLegacyCreateOperation>;
 
 export const unsignedLegacyCreateOperation: v.Type<t.UnsignedLegacyCreateOperation> =
@@ -58,108 +56,17 @@ export const legacyCreateOperation: v.Type<t.LegacyCreateOperation> = _unsignedL
 
 // #region plc_operation
 export const service: v.Type<t.Service> = v.object({
-	type: v.string().assert((input) => input.length <= 256, `service type too long (max 256 characters)`),
-	endpoint: v
-		.string()
-		.assert((input) => input.length <= 512, `service endpoint too long (max 512 characters)`),
+	type: v.string(),
+	endpoint: v.string(),
 });
 
 const _unsignedOperation = v.object({
 	type: v.literal('plc_operation'),
 	prev: v.string().nullable(),
-	rotationKeys: v.array(didKeyString).chain((input) => {
-		const length = input.length;
-
-		if (length === 0) {
-			return v.err(`missing rotation keys`);
-		} else if (length > 10) {
-			return v.err(`too many rotation keys (max 10 keys)`);
-		}
-
-		for (let i = 0; i < length; i++) {
-			const key = input[i];
-
-			for (let j = 0; j < i; j++) {
-				if (input[j] === key) {
-					return v.err({
-						message: `duplicate "${key}" rotation key`,
-						path: [i],
-					});
-				}
-			}
-		}
-
-		return v.ok(input);
-	}),
-	verificationMethods: v.record(permissiveDidKeyString).chain((input) => {
-		const length = Object.keys(input).length;
-
-		if (length > 10) {
-			return v.err(`too many verification method entries (max 10)`);
-		}
-
-		for (const id in input) {
-			const key = input[id];
-
-			if (id.length > 32) {
-				return v.err({
-					message: `verification method id too long (max 32 characters)`,
-					path: [id],
-				});
-			}
-
-			if (key.length > 256) {
-				return v.err({
-					message: `verification method key too long (max 256 characters)`,
-					path: [id],
-				});
-			}
-		}
-
-		return v.ok(input);
-	}),
-	alsoKnownAs: v
-		.array(v.string().assert((input) => input.length <= 256, `aka entry too long (max 256 characters)`))
-		.chain((input) => {
-			const length = input.length;
-
-			if (length > 10) {
-				return v.err(`too many aka entries (max 10)`);
-			}
-
-			for (let i = 0; i < length; i++) {
-				const aka = input[i];
-
-				for (let j = 0; j < i; j++) {
-					if (input[j] === aka) {
-						return v.err({
-							message: `duplicate "${aka}" aka entry`,
-							path: [i],
-						});
-					}
-				}
-			}
-
-			return v.ok(input);
-		}),
-	services: v.record(service).chain((input) => {
-		const length = Object.keys(input).length;
-
-		if (length > 10) {
-			return v.err(`too many service entries (max 10)`);
-		}
-
-		for (const id in input) {
-			if (id.length > 32) {
-				return v.err({
-					message: `service id too long (max 32 characters)`,
-					path: [id],
-				});
-			}
-		}
-
-		return v.ok(input);
-	}),
+	rotationKeys: v.array(didKeyString),
+	verificationMethods: v.record(permissiveDidKeyString),
+	alsoKnownAs: v.array(v.string()),
+	services: v.record(service),
 }) satisfies v.Type<t.UnsignedOperation>;
 
 export const unsignedOperation: v.Type<t.UnsignedOperation> = _unsignedOperation;
@@ -213,3 +120,18 @@ export const indexedEntryLog: v.Type<t.IndexedEntryLog> = v
 	.tuple([_indexedEntry.extend({ operation: compatibleOperation })])
 	.concat(v.array(_indexedEntry.extend({ operation: operationOrTombstone })));
 // #endregion
+
+// #region Client response schemas
+export const plcState: v.Type<t.PlcState> = v.object({
+	did: didPlcString,
+	rotationKeys: v.array(didKeyString),
+	verificationMethods: v.record(permissiveDidKeyString),
+	alsoKnownAs: v.array(v.string()),
+	services: v.record(service),
+});
+
+export const sequencedEntry: v.Type<t.SequencedEntry> = _indexedEntry.extend({
+	type: v.literal('sequenced_op'),
+	seq: v.number(),
+});
+// #endregion

package/lib/types.ts

@@ -71,3 +71,26 @@ export type IndexedEntryLog = [
 	genesis: IndexedEntry<CompatibleOperation>,
 	...IndexedEntry<OperationOrTombstone>[],
 ];
+
+// #region client response types
+
+/**
+ * current identity state derived from the did:plc operation log
+ */
+export interface PlcState {
+	did: DidPlcString;
+	rotationKeys: DidKeyString[];
+	verificationMethods: Record<string, DidKeyString>;
+	alsoKnownAs: string[];
+	services: Record<string, Service>;
+}
+
+/**
+ * operation entry with sequence number from /export endpoint
+ */
+export interface SequencedEntry extends IndexedEntry {
+	type: 'sequenced_op';
+	seq: number;
+}
+
+// #endregion

package/lib/utils.ts

@@ -1,6 +1,8 @@
 import * as CBOR from '@atcute/cbor';
+import type { PrivateKey } from '@atcute/crypto';
 import { verifySigWithDidKey } from '@atcute/crypto';
-import { fromBase64Url } from '@atcute/multibase';
+import { fromBase64Url, toBase32, toBase64Url } from '@atcute/multibase';
+import { toSha256 } from '@atcute/uint8array';
 
 import * as t from './types.js';
 
@@ -22,6 +24,17 @@ export const wrapAtprotoPrefix = (str: string): string => {
 	return `at://${stripped}`;
 };
 
+/**
+ * derives the did:plc identifier from a genesis operation
+ * @param op signed genesis operation
+ * @returns the did:plc string
+ */
+export const deriveDidFromGenesisOp = async (op: t.CompatibleOperation): Promise<t.DidPlcString> => {
+	const opBytes = CBOR.encode(op);
+	const hash = await toSha256(opBytes);
+	return `did:plc:${toBase32(hash).slice(0, 24)}`;
+};
+
 export const normalizeOp = (op: t.CompatibleOperation): t.Operation => {
 	if (op.type === 'create') {
 		return {
@@ -64,3 +77,33 @@ export const isSignedOperationValid = async (
 
 	return null;
 };
+
+// #region signing operations
+
+/**
+ * signs an unsigned plc operation
+ * @param op unsigned operation to sign
+ * @param key private key to sign with (must be one of the rotation keys)
+ * @returns signed operation
+ */
+export const signOperation = async (op: t.UnsignedOperation, key: PrivateKey): Promise<t.Operation> => {
+	const data = CBOR.encode(op);
+	const sig = await key.sign(data);
+
+	return { ...op, sig: toBase64Url(sig) };
+};
+
+/**
+ * signs an unsigned plc tombstone
+ * @param op unsigned tombstone to sign
+ * @param key private key to sign with (must be one of the rotation keys)
+ * @returns signed tombstone
+ */
+export const signTombstone = async (op: t.UnsignedTombstone, key: PrivateKey): Promise<t.Tombstone> => {
+	const data = CBOR.encode(op);
+	const sig = await key.sign(data);
+
+	return { ...op, sig: toBase64Url(sig) };
+};
+
+// #endregion

package/package.json

@@ -1,7 +1,7 @@
 {
   "type": "module",
   "name": "@atcute/did-plc",
-  "version": "0.1.7",
+  "version": "0.3.0",
   "description": "validations, type definitions and schemas for did:plc operations",
   "keywords": [
     "atproto",
@@ -13,6 +13,9 @@
     "url": "https://github.com/mary-ext/atcute",
     "directory": "packages/identity/did-plc"
   },
+  "publishConfig": {
+    "access": "public"
+  },
   "files": [
     "dist/",
     "lib/",
@@ -24,21 +27,23 @@
   },
   "sideEffects": false,
   "devDependencies": {
-    "@types/bun": "^1.2.21"
+    "@vitest/coverage-v8": "^4.0.16",
+    "vitest": "^4.0.16"
   },
   "dependencies": {
     "@badrap/valita": "^0.4.6",
-    "@atcute/cbor": "^2.2.6",
-    "@atcute/crypto": "^2.2.5",
-    "@atcute/cid": "^2.2.4",
-    "@atcute/identity": "^1.1.1",
-    "@atcute/lexicons": "^1.2.2",
+    "@atcute/cbor": "^2.2.8",
+    "@atcute/cid": "^2.2.6",
+    "@atcute/crypto": "^2.3.0",
+    "@atcute/identity": "^1.1.3",
+    "@atcute/lexicons": "^1.2.6",
     "@atcute/multibase": "^1.1.6",
-    "@atcute/uint8array": "^1.0.5"
+    "@atcute/uint8array": "^1.0.6",
+    "@atcute/util-fetch": "^1.0.4"
   },
   "scripts": {
-    "build": "tsc --project tsconfig.build.json",
-    "test": "bun test --coverage",
+    "build": "tsgo --project tsconfig.build.json",
+    "test": "vitest",
     "prepublish": "rm -rf dist; pnpm run build"
   }
 }