diff --git a/inc/admin/namespace.php b/inc/admin/namespace.php
index d64d365..17ccf46 100644
--- a/inc/admin/namespace.php
+++ b/inc/admin/namespace.php
@@ -2,19 +2,28 @@
 
 namespace MiniFAIR\Admin;
 
+use Exception;
 use MiniFAIR;
-use MiniFAIR\PLC\DID;
 use MiniFAIR\Keys;
+use MiniFAIR\PLC\DID;
 use WP_Post;
 
-const NONCE_CREATE_ACTION = 'minifair_create';
-const NONCE_SYNC_ACTION = 'minifair_sync';
+const ACTION_CREATE = 'create';
+const ACTION_EXPORT = 'export';
+const ACTION_IMPORT = 'import';
+const ACTION_KEY_ADD = 'key_add';
+const ACTION_KEY_REVOKE = 'key_revoke';
+const ACTION_SYNC = 'sync';
+const NONCE_PREFIX = 'minifair_';
 const PAGE_SLUG = 'minifair';
 
 function bootstrap() {
 	// Register the admin menu and page before the PLC DID post type is registered.
 	add_action( 'admin_menu', __NAMESPACE__ . '\\add_admin_menu', 0 );
-	add_action( 'post_action_sync', __NAMESPACE__ . '\\maybe_on_sync' );
+	add_action( 'post_action_' . ACTION_EXPORT, __NAMESPACE__ . '\\handle_action', 10, 1 );
+	add_action( 'post_action_' . ACTION_KEY_ADD, __NAMESPACE__ . '\\handle_action', 10, 1 );
+	add_action( 'post_action_' . ACTION_KEY_REVOKE, __NAMESPACE__ . '\\handle_action', 10, 1 );
+	add_action( 'post_action_' . ACTION_SYNC, __NAMESPACE__ . '\\handle_action', 10, 1 );
 
 	// Hijack the post-new.php page to render our own form.
 	add_action( 'replace_editor', function ( $res, WP_Post $post ) {
@@ -44,6 +53,15 @@ function add_admin_menu() {
 }
 
 function load_settings_page() {
+	if ( ! isset( $_POST['action'] ) ) {
+		return;
+	}
+
+	switch ( $_POST['action'] ) {
+		case ACTION_IMPORT:
+			on_import();
+			break;
+	}
 }
 
 function render_settings_page() {
@@ -115,6 +133,8 @@ function render_settings_page() {
 			</table>
 		<?php endif; ?>
 
+		<hr />
+
 		<h2><?php esc_html_e( 'Publish a New Package', 'minifair' ); ?></h2>
 		<p><?php esc_html_e( 'The first step in publishing a new package is to create a DID for it. This will act as the permanent, globally-unique ID for your package.', 'minifair' ); ?></p>
 		<p>
@@ -122,10 +142,71 @@ function render_settings_page() {
 				<?php esc_html_e( 'Create New PLC DID…', 'minifair' ); ?>
 			</a>
 		</p>
+
+		<h2><?php esc_html_e( 'Import an existing DID', 'minifair' ); ?></h2>
+		<p><?php esc_html_e( 'If you have an existing DID that you want to import from another Mini FAIR site, you can do so here.', 'minifair' ); ?></p>
+		<p><?= wp_kses_post( __( '<strong>Note:</strong> Registering a single DID with multiple sites may break your DID.', 'minifair' ) ); ?></p>
+		<form action="" method="post" enctype="multipart/form-data">
+			<p>
+				<input
+					type="file"
+					id="did_json"
+					name="did_json"
+				/>
+			</p>
+			<?php wp_nonce_field( NONCE_PREFIX . ACTION_IMPORT ); ?>
+			<input type="hidden" name="action" value="<?= esc_attr( ACTION_IMPORT ) ?>" />
+			<?php submit_button( __( 'Import DID', 'minifair' ), 'primary', 'import_did' ); ?>
 	</div>
 	<?php
 }
 
+function on_import() {
+	check_admin_referer( NONCE_PREFIX . ACTION_IMPORT );
+
+	// Check user permissions.
+	if ( ! current_user_can( 'manage_options' ) ) {
+		wp_die( __( 'You do not have sufficient permissions to access this page.', 'minifair' ) );
+	}
+
+	// Handle the form submission to import a DID.
+	$did_json = $_FILES['did_json'] ?? null;
+	if ( empty( $did_json ) || empty( $did_json['tmp_name'] ) ) {
+		wp_admin_notice( __( 'No DID JSON file uploaded.', 'minifair' ) );
+		return;
+	}
+
+	$data = json_decode( file_get_contents( $did_json['tmp_name'] ), true );
+	if ( json_last_error() !== JSON_ERROR_NONE ) {
+		wp_admin_notice(
+			sprintf(
+				__( 'Could not parse DID JSON: %s', 'minifair' ),
+				json_last_error_msg()
+			),
+			[
+				'type' => 'error',
+			]
+		);
+		return;
+	}
+
+	try {
+		$did = DID::import( $data );
+		wp_redirect( get_edit_post_link( $did->get_internal_post_id(), 'raw' ) );
+		exit;
+	} catch ( Exception $e ) {
+		wp_admin_notice(
+			sprintf(
+				__( 'Could not import DID: %s', 'minifair' ),
+				$e->getMessage()
+			),
+			[
+				'type' => 'error',
+			]
+		);
+	}
+}
+
 function fetch_did( DID $did ) {
 	$url = DID::DIRECTORY_API . '/' . $did->id;
 	$res = MiniFAIR\get_remote_url( $url );
@@ -137,6 +218,10 @@ function fetch_did( DID $did ) {
 }
 
 function render_editor() {
+	if ( isset( $_POST['action'] ) && $_POST['action'] === ACTION_CREATE ) {
+		on_create();
+	}
+
 	require_once ABSPATH . 'wp-admin/admin-header.php';
 
 	echo '<div class="wrap">';
@@ -155,27 +240,37 @@ function render_editor() {
 	}
 }
 
-function render_new_page( WP_Post $post ) {
+function on_create() {
+	check_admin_referer( NONCE_PREFIX . ACTION_CREATE );
+
 	// Check user permissions.
 	if ( ! current_user_can( 'manage_options' ) ) {
 		wp_die( __( 'You do not have sufficient permissions to access this page.', 'minifair' ) );
 	}
 
-	if ( isset( $_POST['action'] ) ) {
-		if ( $_POST['action'] !== 'create' ) {
-			wp_die( __( 'Invalid action.', 'minifair' ) );
-		}
-
-		check_admin_referer( NONCE_CREATE_ACTION );
+	// Handle the form submission to create a new PLC DID.
+	$did = DID::create();
+	if ( is_wp_error( $did ) ) {
+		wp_admin_notice(
+			sprintf(
+				__( 'Could not create DID: %s', 'minifair' ),
+				$did->get_error_message()
+			),
+			[
+				'type'               => 'error',
+				'additional_classes' => [ 'notice-alt' ],
+			]
+		);
+	} else {
+		wp_redirect( get_edit_post_link( $did->get_internal_post_id(), 'raw' ) );
+		exit;
+	}
+}
 
-		// Handle the form submission to create a new PLC DID.
-		$did = DID::create();
-		if ( is_wp_error( $did ) ) {
-			echo '<div class="error"><p>' . esc_html( $did->get_error_message() ) . '</p></div>';
-		} else {
-			wp_redirect( get_edit_post_link( $did->get_internal_post_id(), 'raw' ) );
-			exit;
-		}
+function render_new_page( WP_Post $post ) {
+	// Check user permissions.
+	if ( ! current_user_can( 'manage_options' ) ) {
+		wp_die( __( 'You do not have sufficient permissions to access this page.', 'minifair' ) );
 	}
 
 	?>
@@ -183,9 +278,9 @@ function render_new_page( WP_Post $post ) {
 	<p><?php esc_html_e( 'PLC DIDs are permanent, and publicly available in the PLC directory.', 'minifair' ) ?></p>
 
 	<form action="" method="post">
-		<?php wp_nonce_field( NONCE_CREATE_ACTION ) ?>
+		<?php wp_nonce_field( NONCE_PREFIX . ACTION_CREATE ) ?>
 		<input type="hidden" name="post" value="<?php echo esc_attr( $post->ID ); ?>" />
-		<input type="hidden" name="action" value="create" />
+		<input type="hidden" name="action" value="<?= esc_attr( ACTION_CREATE ) ?>" />
 
 		<table class="form-table">
 			<!-- <tr>
@@ -208,25 +303,127 @@ function render_new_page( WP_Post $post ) {
 	<?php
 }
 
-function maybe_on_sync( int $post_id ) {
+function handle_action( int $post_id ) {
 	$post = get_post( $post_id );
 	if ( ! $post || $post->post_type !== DID::POST_TYPE ) {
 		return;
 	}
 
-	// Handle the form submission to sync the PLC DID with the PLC Directory.
-	check_admin_referer( NONCE_SYNC_ACTION );
+	$action = $_REQUEST['action'] ?? '';
+	if ( empty( $action ) ) {
+		// This should never occur, since we're hooked into specific actions above.
+		wp_die( __( 'No action specified.', 'minifair' ), '', [ 'response' => 400 ] );
+	}
+
+	check_admin_referer( NONCE_PREFIX . $action );
 
 	$did = DID::from_post( $post );
+	switch ( $action ) {
+		case ACTION_KEY_ADD:
+			on_add_key( $did );
+			break;
+		case ACTION_KEY_REVOKE:
+			on_revoke_key( $did );
+			break;
+		case ACTION_EXPORT:
+			on_export( $did );
+			break;
+		case ACTION_SYNC:
+			on_sync( $did );
+			break;
+		default:
+			wp_die( __( 'Invalid action.', 'minifair' ), '', [ 'response' => 400 ] );
+	}
+}
+
+function on_sync( DID $did ) {
+	check_admin_referer( NONCE_PREFIX . ACTION_SYNC );
+
+	try {
+		$did->update();
+		wp_redirect( get_edit_post_link( $did->get_internal_post_id(), 'raw' ) );
+		exit;
+	} catch ( \Exception $e ) {
+		wp_die( $e->getMessage(), __( 'Error Syncing PLC DID', 'minifair' ), [ 'response' => 500 ] );
+	}
+}
+
+function on_add_key( DID $did ) {
+	// Handle adding a new verification key.
+	$did->generate_verification_key();
+
 	try {
 		$did->update();
+		$did->save();
 		wp_redirect( get_edit_post_link( $did->get_internal_post_id(), 'raw' ) );
 		exit;
 	} catch ( \Exception $e ) {
+		var_dump( $e );
 		wp_die( $e->getMessage(), __( 'Error Syncing PLC DID', 'minifair' ), [ 'response' => 500 ] );
 	}
 }
 
+function on_revoke_key( DID $did ) {
+	// Handle revoking an existing verification key.
+	$key_id = $_POST['key_id'] ?? '';
+	if ( empty( $key_id ) ) {
+		wp_die( __( 'No key ID specified.', 'minifair' ), '', [ 'response' => 400 ] );
+	}
+
+	// Find corresponding private key.
+	$keys = $did->get_verification_keys();
+	$key = array_find( $keys, fn ( $k ) => $k->encode_public() === $key_id );
+	if ( empty( $key ) ) {
+		wp_die( __( 'Invalid key ID.', 'minifair' ), '', [ 'response' => 400 ] );
+	}
+
+	if ( ! $did->invalidate_verification_key( $key ) ) {
+		wp_die( __( 'Failed to revoke key.', 'minifair' ), '', [ 'response' => 500 ] );
+	}
+
+	try {
+		$did->update();
+		$did->save();
+		wp_redirect( get_edit_post_link( $did->get_internal_post_id(), 'raw' ) );
+		exit;
+	} catch ( Exception $e ) {
+		var_dump( $e );
+		wp_die( $e->getMessage(), __( 'Error Syncing PLC DID', 'minifair' ), [ 'response' => 500 ] );
+	}
+}
+
+/**
+ * Handle an export request for a DID.
+ *
+ * @return void Handles the request, then exits.
+ */
+function on_export( DID $did ) : void {
+	// Handle exporting the DID document.
+	check_admin_referer( NONCE_PREFIX . ACTION_EXPORT );
+
+	// Double-check the permissions.
+	if ( ! current_user_can( 'manage_options' ) ) {
+		wp_die( __( 'You do not have sufficient permissions to perform this action.', 'minifair' ), '', [ 'response' => 403 ] );
+	}
+
+	$document = $did->export();
+	if ( ! $document ) {
+		wp_die( __( 'Failed to export DID document.', 'minifair' ), '', [ 'response' => 500 ] );
+	}
+
+	// Send the document to the browser for download.
+	header( 'Content-Type: application/json' );
+	header(
+		sprintf(
+			'Content-Disposition: attachment; filename="did-%s.json"',
+			str_replace( 'did:plc:', '', $did->id )
+		)
+	);
+	header( 'Cache-Control: no-store, no-cache, must-revalidate, max-age=0' );
+	echo json_encode( $document, JSON_PRETTY_PRINT );
+	exit;
+}
+
 function render_edit_page( WP_Post $post ) {
 	// Check user permissions.
 	if ( ! current_user_can( 'manage_options' ) ) {
@@ -255,7 +452,7 @@ function render_edit_page( WP_Post $post ) {
 			<td>
 				<ol>
 					<?php foreach ( $did->get_rotation_keys() as $key ) : ?>
-						<li><code><?php echo esc_html( Keys\encode_public_key( $key, Keys\CURVE_K256 ) ); ?></code></li>
+						<li><code><?php echo esc_html( $key->encode_public() ); ?></code></li>
 					<?php endforeach; ?>
 				</ol>
 				<p class="description"><?php esc_html_e( 'Rotation keys are used to manage the DID itself.', 'minifair' ); ?></p>
@@ -266,12 +463,56 @@ function render_edit_page( WP_Post $post ) {
 				<label for="recovery"><?php esc_html_e( 'Verification Public Keys', 'minifair' ); ?></label>
 			</th>
 			<td>
+				<p class="description"><?php esc_html_e( 'Verification keys are used for package signing. Your newest (last) key is used for signing, but older keys are still used for verification. Revoking any key will invalidate any older packages which may be cached, so should only be done after some time (such as a week) has passed.', 'minifair' ); ?></p>
 				<ol>
-					<?php foreach ( $did->get_verification_keys() as $key ) : ?>
-						<li><code><?php echo esc_html( Keys\encode_public_key( $key, Keys\CURVE_K256 ) ); ?></code></li>
+					<?php
+					$verification_keys = $did->get_verification_keys();
+					$last = end( $verification_keys );
+					foreach ( $verification_keys as $key ) : ?>
+						<?php
+						$public = $key->encode_public();
+						$id = substr( hash( 'sha256', $public ), 0, 6 );
+						?>
+						<li>
+							<code>fair_<?= esc_html( $id ); ?></code>:
+							<code><?= esc_html( $public ); ?></code>
+							<?php if ( $key instanceof Keys\ECKey ) : ?>
+								<p><small><em>(Key is using outdated algorithm and should be replaced.)</em></small></p>
+							<?php endif; ?>
+							<?php if ( $key === $last ): ?>
+								<p><small><strong>Current</strong></small></p>
+							<?php endif; ?>
+
+							<form action="" method="post">
+								<?php wp_nonce_field( NONCE_PREFIX . ACTION_KEY_REVOKE ); ?>
+								<input type="hidden" name="post" value="<?= esc_attr( $post->ID ); ?>" />
+								<input type="hidden" name="action" value="<?= esc_attr( ACTION_KEY_REVOKE ); ?>" />
+								<input type="hidden" name="key_id" value="<?= esc_attr( $key->encode_public() ); ?>" />
+								<?php
+								$disabled = count( $verification_keys ) === 1
+									? [
+										'disabled' => 'disabled',
+										'title' => __( 'You must have at least one verification key.', 'minifair' ),
+									]
+									: [];
+
+								submit_button(
+									__( 'Revoke', 'minifair' ),
+									'',
+									'revoke_verification_key',
+									true,
+									$disabled
+								); ?>
+							</form>
+						</li>
 					<?php endforeach; ?>
 				</ol>
-				<p class="description"><?php esc_html_e( 'Verification keys are used for package signing.', 'minifair' ); ?></p>
+				<form action="" method="post">
+					<?php wp_nonce_field( NONCE_PREFIX . ACTION_KEY_ADD ); ?>
+					<input type="hidden" name="post" value="<?= esc_attr( $post->ID ); ?>" />
+					<input type="hidden" name="action" value="<?= esc_attr( ACTION_KEY_ADD ); ?>" />
+					<?php submit_button( __( 'Add new key', 'minifair' ), '', 'add_verification_key' ); ?>
+				</form>
 			</td>
 		</tr>
 		<tr>
@@ -296,14 +537,45 @@ function render_edit_page( WP_Post $post ) {
 			</th>
 			<td>
 				<p><?php esc_html_e( 'If the service endpoint or keys have changed, you can resync to the PLC Directory.', 'minifair' ); ?></p>
+				<details>
+					<summary><?php esc_html_e( 'Expected changes', 'minifair' ); ?></summary>
+					<?php
+					$current = $remote;
+					unset( $current['@context'] );
+					$diff = wp_text_diff(
+						json_encode( $current, JSON_PRETTY_PRINT | JSON_UNESCAPED_SLASHES ),
+						json_encode( $did->get_expected_document(), JSON_PRETTY_PRINT | JSON_UNESCAPED_SLASHES )
+					);
+					if ( empty( $diff ) ) {
+						echo '<p class="description">' . esc_html__( 'No changes detected. The PLC Directory is already up to date.', 'minifair' ) . '</p>';
+					} else {
+						echo '<div class="diff">' . $diff . '</div>';
+					}
+					?>
+				</details>
 				<form action="" method="post">
-					<?php wp_nonce_field( NONCE_SYNC_ACTION ); ?>
+					<?php wp_nonce_field( NONCE_PREFIX . ACTION_SYNC ); ?>
 					<input type="hidden" name="post" value="<?php echo esc_attr( $post->ID ); ?>" />
-					<input type="hidden" name="action" value="sync" />
+					<input type="hidden" name="action" value="<?= esc_attr( ACTION_SYNC ) ?>" />
 					<?php submit_button( __( 'Sync to PLC Directory', 'minifair' ), 'primary', 'update_did' ); ?>
 				</form>
 			</td>
 		</tr>
+		<tr>
+			<th scope="row">
+				<?php esc_html_e( 'Export', 'minifair' ) ?>
+			</th>
+			<td>
+				<p><?php esc_html_e( "Need to move this DID to a different directory? Export the DID's data here.", 'minifair' ); ?></p>
+				<p><?php echo wp_kses_post( __( "<strong>Warning:</strong> This export contains the <strong>private key material</strong> to control this DID. Ensure you keep it safe, as DIDs are <strong>unrecoverable</strong> if lost.", 'minifair' ) ); ?></p>
+				<form action="" method="post">
+					<?php wp_nonce_field( NONCE_PREFIX . ACTION_EXPORT ); ?>
+					<input type="hidden" name="post" value="<?php echo esc_attr( $post->ID ); ?>" />
+					<input type="hidden" name="action" value="<?= esc_attr( ACTION_EXPORT ) ?>" />
+					<?php submit_button( __( 'Export DID Document', 'minifair' ), 'primary', 'export_did' ); ?>
+				</form>
+			</td>
+		</tr>
 	</table>
 
 	<?php
diff --git a/inc/git-updater/namespace.php b/inc/git-updater/namespace.php
index 8674657..334d268 100644
--- a/inc/git-updater/namespace.php
+++ b/inc/git-updater/namespace.php
@@ -104,10 +104,21 @@ function get_artifact_metadata( DID $did, $url ) {
  * @return array|WP_Error
  */
 function generate_artifact_metadata( DID $did, $url ) {
-	$signing_key = $did->get_verification_keys()[0] ?? null;
-	if ( ! $signing_key ) {
-		var_dump( 'No signing key found for DID' );
-		return;
+	$keys = $did->get_verification_keys();
+	if ( empty( $keys ) ) {
+		return new WP_Error(
+			'minifair.generate_artifact_metadata.missing_keys',
+			__( 'No verification keys found for DID', 'minifair' )
+		);
+	}
+
+	// todo: make active key selectable
+	$signing_key = end( $keys );
+	if ( empty( $signing_key ) ) {
+		return new WP_Error(
+			'minifair.generate_artifact_metadata.missing_signing_key',
+			__( 'No signing key found for DID', 'minifair' )
+		);
 	}
 
 	$artifact_id = sprintf( '%s:%s', $did->id, substr( sha1( $url ), 0, 8 ) );
diff --git a/inc/keys/class-eckey.php b/inc/keys/class-eckey.php
new file mode 100644
index 0000000..ee1efe6
--- /dev/null
+++ b/inc/keys/class-eckey.php
@@ -0,0 +1,206 @@
+<?php
+
+namespace MiniFAIR\Keys;
+
+use Elliptic\EC;
+use Elliptic\EC\KeyPair;
+use Elliptic\EC\Signature;
+use Elliptic\Utils;
+use Exception;
+use YOCLIB\Multiformats\Multibase\Multibase;
+
+class ECKey implements Key {
+	public function __construct(
+		protected KeyPair $keypair,
+		protected string $curve
+	) {
+	}
+
+	/**
+	 * Does this key represent a private key?
+	 *
+	 * @return bool True if the key is a private keypair, false if it is a public key.
+	 */
+	public function is_private() : bool {
+		return $this->keypair->getPrivate() !== null;
+	}
+
+	/**
+	 * Convert a keypair object to a multibase public key string.
+	 *
+	 * @see https://atproto.com/specs/cryptography
+	 *
+	 * @return string The multibase public key string (starts with z).
+	 */
+	public function encode_public() : string {
+		$pub = $this->keypair->getPublic( true, 'hex' );
+		$prefix = match ( $this->curve ) {
+			CURVE_K256 => bin2hex( PREFIX_CURVE_K256 ),
+			CURVE_P256 => bin2hex( PREFIX_CURVE_P256 ),
+			default => throw new Exception( 'Unsupported curve' ),
+		};
+		$encoded = Multibase::encode( Multibase::BASE58BTC, hex2bin( $prefix . $pub ) );
+		return $encoded;
+	}
+
+	/**
+	 * Convert a keypair object to a multibase private key string.
+	 *
+	 * @see https://atproto.com/specs/cryptography
+	 *
+	 * @return string The multibase private key string (starts with z).
+	 */
+	public function encode_private() : string {
+		if ( ! $this->is_private() ) {
+			throw new Exception( 'Cannot encode private key for a public key' );
+		}
+
+		$priv = $this->keypair->getPrivate( 'hex' );
+		$prefix = match ( $this->curve ) {
+			CURVE_K256 => bin2hex( PREFIX_CURVE_K256_PRIVATE ),
+			CURVE_P256 => bin2hex( PREFIX_CURVE_P256_PRIVATE ),
+			default => throw new Exception( 'Unsupported curve' ),
+		};
+		$encoded = Multibase::encode( Multibase::BASE58BTC, hex2bin( $prefix . $priv ));
+		return $encoded;
+	}
+
+	/**
+	 * Convert a key to an incorrectly-encoded key string.
+	 *
+	 * Used only for revocation.
+	 *
+	 * @throws Exception If the curve is not supported.
+	 * @return string The multibase private key string (starts with z).
+	 */
+	public function encode_private_legacy_do_not_use_or_you_will_be_fired() : string {
+		if ( ! $this->is_private() ) {
+			throw new Exception( 'Cannot encode private key for a public key' );
+		}
+
+		$priv = $this->keypair->getPrivate( 'hex' );
+		$prefix = match ( $this->curve ) {
+			CURVE_K256 => bin2hex( PREFIX_CURVE_K256 ),
+			CURVE_P256 => bin2hex( PREFIX_CURVE_P256 ),
+			default => throw new Exception( 'Unsupported curve' ),
+		};
+		$encoded = Multibase::encode( Multibase::BASE58BTC, hex2bin( $prefix . $priv ));
+		return $encoded;
+	}
+
+	/**
+	 * Convert a signature to compact (IEEE-P1363) representation.
+	 *
+	 * (Equivalent to secp256k1_ecdsa_sign_compact().)
+	 *
+	 * @internal Elliptic does not support compact signatures, only DER-encoded, so
+	 *           we need to do it ourselves. Compact signatures are just the r and
+	 *           s bytes concatenated, but must be padded to 32 bytes each.
+	 *
+	 * @param EC $ec The elliptic curve object.
+	 * @param Signature $signature The signature object.
+	 * @return string The compact signature.
+	 */
+	protected function signature_to_compact( EC $ec, Signature $signature ) : string {
+		$byte_length = ceil( $ec->curve->n->bitLength() / 8 );
+		$compact = Utils::toHex( $signature->r->toArray( 'be', $byte_length ) ) . Utils::toHex( $signature->s->toArray( 'be', $byte_length ) );
+		return $compact;
+	}
+
+	/**
+	 * Sign data using the private key.
+	 *
+	 * @param string $data The data to sign, as a hex-encoded string.
+	 * @return string The signature encoded as a binary string.
+	 */
+	public function sign( string $data ) : string {
+		if ( ! $this->is_private() ) {
+			throw new Exception( 'Cannot sign with a public key' );
+		}
+
+		/**
+		 * Hash with SHA-256, then sign, using canonical (low-S) form.
+		 *
+		 * @var \Elliptic\EC\Signature
+		 */
+		$signature = $this->keypair->sign( $data, 'hex', [
+			'canonical' => true
+		] );
+
+		// Convert to compact (IEEE-P1363) form.
+		// todo: do we need to do this for p256 too?
+		if ( $this->curve === CURVE_K256 ) {
+			return $this->signature_to_compact( $this->keypair->ec, $signature );
+		}
+		return $signature->toDER( 'hex' );
+	}
+
+	/**
+	 * Generate a new keypair.
+	 *
+	 * We use NIST K-256 as the default to match ATProto.
+	 *
+	 * @see https://atproto.com/specs/cryptography
+	 *
+	 * @throws Exception If the curve is not supported.
+	 * @return static The generated keypair object.
+	 */
+	public static function generate( string $curve ) : static {
+		$ec = new EC( $curve );
+		return new static( $ec->genKeyPair(), $curve );
+	}
+
+	/**
+	 * Convert a multibase public key string to a keypair object.
+	 *
+	 * @see https://atproto.com/specs/cryptography
+	 *
+	 * @throws Exception If the curve is not supported.
+	 * @param string $key The multibase public key string (starts with z).
+	 * @return static The key object.
+	 */
+	public static function from_public( string $key ) : static {
+		$decoded = Multibase::decode( $key );
+
+		$curve = match ( substr( $decoded, 0, 2 ) ) {
+			PREFIX_CURVE_P256 => CURVE_P256,
+			PREFIX_CURVE_K256 => CURVE_K256,
+			default => throw new Exception( 'Unsupported curve' ),
+		};
+
+		$ec = new EC( $curve );
+
+		$stripped = bin2hex( substr( $decoded, 2 ) );
+		$keypair = $ec->keyFromPublic( $stripped, 'hex' );
+		return new static( $keypair, $curve );
+	}
+
+	/**
+	 * Convert a multibase private key string to a keypair object.
+	 *
+	 * @see https://atproto.com/specs/cryptography
+	 *
+	 * @throws Exception If the curve is not supported.
+	 * @param string $key The multibase public key string (starts with z).
+	 * @return static The key object.
+	 */
+	public static function from_private( string $key ) : static {
+		$decoded = Multibase::decode( $key );
+
+		$curve = match ( substr( $decoded, 0, 2 ) ) {
+			PREFIX_CURVE_P256_PRIVATE => CURVE_P256,
+			PREFIX_CURVE_K256_PRIVATE => CURVE_K256,
+
+			// todo: Legacy, remove this later.
+			PREFIX_CURVE_P256 => CURVE_P256,
+			PREFIX_CURVE_K256 => CURVE_K256,
+			default => throw new Exception( 'Unsupported curve' ),
+		};
+
+		$ec = new EC( $curve );
+
+		$stripped = bin2hex( substr( $decoded, 2 ) );
+		$keypair = $ec->keyFromPrivate( $stripped, 'hex' );
+		return new static( $keypair, $curve );
+	}
+}
diff --git a/inc/keys/class-eddsakey.php b/inc/keys/class-eddsakey.php
new file mode 100644
index 0000000..dc5220a
--- /dev/null
+++ b/inc/keys/class-eddsakey.php
@@ -0,0 +1,168 @@
+<?php
+
+namespace MiniFAIR\Keys;
+
+use Elliptic\EdDSA;
+use Elliptic\EdDSA\KeyPair;
+use Exception;
+use YOCLIB\Multiformats\Multibase\Multibase;
+
+class EdDSAKey implements Key {
+	public function __construct(
+		protected KeyPair $keypair,
+		protected string $curve
+	) {
+	}
+
+	/**
+	 * Does this key represent a private key?
+	 *
+	 * @return bool True if the key is a private keypair, false if it is a public key.
+	 */
+	public function is_private() : bool {
+		return $this->keypair->secret() !== null;
+	}
+
+	/**
+	 * Sign data using the private key.
+	 *
+	 * @param string $data The data to sign, as a hex-encoded string.
+	 * @return string The signature encoded as a hex-encoded string.
+	 */
+	public function sign( string $data ) : string {
+		if ( ! $this->is_private() ) {
+			throw new Exception( 'Cannot sign with a public key' );
+		}
+
+		return $this->keypair->sign( $data )->toHex();
+	}
+
+	/**
+	 * Convert a key to a multibase private key string.
+	 *
+	 * @see https://atproto.com/specs/cryptography
+	 *
+	 * @throws Exception If the curve is not supported.
+	 * @return string The multibase private key string (starts with z).
+	 */
+	public function encode_public() : string {
+		$pub = $this->keypair->getPublic( 'hex' );
+		$prefix = match ( $this->curve ) {
+			CURVE_ED25519 => bin2hex( PREFIX_CURVE_ED25519 ),
+			default => throw new Exception( 'Unsupported curve' ),
+		};
+		$encoded = Multibase::encode( Multibase::BASE58BTC, hex2bin( $prefix . $pub ) );
+		return $encoded;
+	}
+
+	/**
+	 * Convert a key to a multibase private key string.
+	 *
+	 * @see https://atproto.com/specs/cryptography
+	 *
+	 * @throws Exception If the curve is not supported.
+	 * @return string The multibase private key string (starts with z).
+	 */
+	public function encode_private() : string {
+		if ( ! $this->is_private() ) {
+			throw new Exception( 'Cannot encode private key for a public key' );
+		}
+
+		$priv = $this->keypair->getSecret( 'hex' );
+		$prefix = match ( $this->curve ) {
+			CURVE_ED25519 => bin2hex( PREFIX_CURVE_ED25519_PRIVATE ),
+			default => throw new Exception( 'Unsupported curve' ),
+		};
+		$encoded = Multibase::encode( Multibase::BASE58BTC, hex2bin( $prefix . $priv ) );
+		return $encoded;
+	}
+
+	/**
+	 * Convert a key to an incorrectly-encoded key string.
+	 *
+	 * Used only for revocation.
+	 *
+	 * @throws Exception If the curve is not supported.
+	 * @return string The multibase private key string (starts with z).
+	 */
+	public function encode_private_legacy_do_not_use_or_you_will_be_fired() : string {
+		if ( ! $this->is_private() ) {
+			throw new Exception( 'Cannot encode private key for a public key' );
+		}
+
+		$priv = $this->keypair->getSecret( 'hex' );
+		$prefix = match ( $this->curve ) {
+			CURVE_ED25519 => bin2hex( PREFIX_CURVE_ED25519 ),
+			default => throw new Exception( 'Unsupported curve' ),
+		};
+		$encoded = Multibase::encode( Multibase::BASE58BTC, hex2bin( $prefix . $priv ) );
+		return $encoded;
+	}
+
+	/**
+	 * Generate a new key.
+	 *
+	 * @return static A new instance of the key.
+	 */
+	public static function generate( string $curve ) : static {
+		// Generate a random keypair.
+		$key = sodium_crypto_sign_keypair();
+		$secret = sodium_crypto_sign_secretkey( $key );
+
+		// Convert to KeyPair object.
+		$ed = new EdDSA( $curve );
+		$key = $ed->keyFromSecret( bin2hex( $secret ) );
+		return new static( $key, $curve );
+	}
+
+	/**
+	 * Convert a multibase public key string to a keypair object.
+	 *
+	 * @see https://atproto.com/specs/cryptography
+	 *
+	 * @throws Exception If the curve is not supported.
+	 * @param string $key The multibase public key string (starts with z).
+	 * @return static The key object.
+	 */
+	public static function from_public( string $key ) : static {
+		$decoded = Multibase::decode( $key );
+
+		$curve = match ( substr( $decoded, 0, 2 ) ) {
+			PREFIX_CURVE_ED25519 => CURVE_ED25519,
+			default => throw new Exception( 'Unsupported curve' ),
+		};
+
+		$eddsa = new EdDSA( $curve );
+
+		$stripped = bin2hex( substr( $decoded, 2 ) );
+		$keypair = $eddsa->keyFromPublic( $stripped, 'hex' );
+		return new static( $keypair, $curve );
+	}
+
+	/**
+	 * Convert a multibase private key string to a keypair object.
+	 *
+	 * @see https://atproto.com/specs/cryptography
+	 *
+	 * @throws Exception If the curve is not supported.
+	 * @param string $key The multibase public key string (starts with z).
+	 * @return static The key object.
+	 */
+	public static function from_private( string $key ) : static {
+		$decoded = Multibase::decode( $key );
+
+		$curve = match ( substr( $decoded, 0, 2 ) ) {
+			PREFIX_CURVE_ED25519_PRIVATE => CURVE_ED25519,
+
+			// todo: Legacy, remove this later.
+			PREFIX_CURVE_ED25519 => CURVE_ED25519,
+			default => throw new Exception( 'Unsupported curve' ),
+		};
+
+		$eddsa = new EdDSA( $curve );
+
+		$stripped = bin2hex( substr( $decoded, 2 ) );
+		$keypair = $eddsa->keyFromSecret( $stripped, 'hex' );
+		return new static( $keypair, $curve );
+	}
+}
diff --git a/inc/keys/class-key.php b/inc/keys/class-key.php
new file mode 100644
index 0000000..ad63d44
--- /dev/null
+++ b/inc/keys/class-key.php
@@ -0,0 +1,62 @@
+<?php
+
+namespace MiniFAIR\Keys;
+
+interface Key {
+	/**
+	 * Does this key represent a private key?
+	 *
+	 * @return bool True if the key is a private keypair, false if it is a public key.
+	 */
+	public function is_private() : bool;
+
+	/**
+	 * Sign data using the private key.
+	 *
+	 * @param string $data The data to sign, as a hex-encoded string.
+	 * @return string The signature encoded as a hex-encoded string.
+	 */
+	public function sign( string $data ) : string;
+
+	/**
+	 * Convert a key to a multibase private key string.
+	 *
+	 * @see https://atproto.com/specs/cryptography
+	 *
+	 * @throws Exception If the curve is not supported.
+	 * @return string The multibase private key string (starts with z).
+	 */
+	public function encode_public() : string;
+
+	/**
+	 * Convert a key to a multibase private key string.
+	 *
+	 * @see https://atproto.com/specs/cryptography
+	 *
+	 * @throws Exception If the curve is not supported.
+	 * @return string The multibase private key string (starts with z).
+	 */
+	public function encode_private() : string;
+
+	/**
+	 * Convert a multibase public key string to a key.
+	 *
+	 * @see https://atproto.com/specs/cryptography
+	 *
+	 * @throws Exception If the curve is not supported.
+	 * @param string $key The multibase public key string (starts with z).
+	 * @return Key The key object.
+	 */
+	public static function from_public( string $key ) : static;
+
+	/**
+	 * Convert a multibase private key string to a key.
+	 *
+	 * @see https://atproto.com/specs/cryptography
+	 *
+	 * @throws Exception If the curve is not supported.
+	 * @param string $key The multibase public key string (starts with z).
+	 * @return Key The key object.
+	 */
+	public static function from_private( string $key ) : static;
+}
diff --git a/inc/keys/namespace.php b/inc/keys/namespace.php
index 4e00781..4fc9b69 100644
--- a/inc/keys/namespace.php
+++ b/inc/keys/namespace.php
@@ -9,21 +9,23 @@
 
 const CURVE_K256 = 'secp256k1';
 const CURVE_P256 = 'p256';
-
-/**
- * Generate a new keypair.
- *
- * We use NIST K-256 as the default to match ATProto.
- *
- * @see https://atproto.com/specs/cryptography
- *
- * @throws Exception If the curve is not supported.
- * @return KeyPair The generated keypair object.
- */
-function generate_keypair() : KeyPair {
-	$ec = new EC( CURVE_K256 );
-	return $ec->genKeyPair();
-}
+const CURVE_ED25519 = 'ed25519';
+
+// From https://github.com/multiformats/multicodec/blob/master/table.csv:
+// 0xe7 0x01 = varint( 0xe7 ) = 231 = secp256k1-pub
+// 0x80 0x24 = varint( 0x80 ) = 128 = p256-pub
+// 0xed 0x01 = varint( 0xed ) = 237 = ed25519-pub
+// 0x81 0x26 = varint( 0x1301 ) = 4865 = secp256k1-priv
+// 0x86 0x26 = varint( 0x1306 ) = 4870 = p256-priv
+// 0x80 0x26 = varint( 0x1300 ) = 4864 = ed25519-priv
+const PREFIX_CURVE_K256 = "\xe7\x01";
+const PREFIX_CURVE_K256_PRIVATE = "\x81\x26";
+const PREFIX_CURVE_P256 = "\x80\x24";
+const PREFIX_CURVE_P256_PRIVATE = "\x06\x26";
+
+// https://www.w3.org/TR/vc-di-eddsa/#ed25519verificationkey2020
+const PREFIX_CURVE_ED25519 = "\xed\x01";
+const PREFIX_CURVE_ED25519_PRIVATE = "\x80\x26"; // 0x1300
 
 /**
  * Convert a multibase public key string to a keypair object.
@@ -32,9 +34,9 @@ function generate_keypair() : KeyPair {
  *
  * @throws Exception If the curve is not supported.
  * @param string $key The multibase public key string (starts with z).
- * @return KeyPair The keypair object.
+ * @return Key The key object.
  */
-function decode_public_key( string $key ) : KeyPair {
+function decode_public_key( string $key ) : Key {
 	static $cache = [];
 	if ( isset( $cache[ $key ] ) ) {
 		return $cache[ $key ];
@@ -42,16 +44,12 @@ function decode_public_key( string $key ) : KeyPair {
 
 	$decoded = Multibase::decode( $key );
 
-	$curve = match ( $decoded[0] ) {
-		"\x80" => CURVE_P256,
-		"\xE7" => CURVE_K256,
+	$keypair = match ( substr( $decoded, 0, 2 ) ) {
+		PREFIX_CURVE_P256    => ECKey::from_public( $key ),
+		PREFIX_CURVE_K256    => ECKey::from_public( $key ),
+		PREFIX_CURVE_ED25519 => EdDSAKey::from_public( $key ),
 		default => throw new Exception( 'Unsupported curve' ),
 	};
-
-	$ec = new EC( $curve );
-
-	$stripped = bin2hex( substr( $decoded, 2 ) );
-	$keypair = $ec->keyFromPublic( $stripped, 'hex' );
 	$cache[ $key ] = $keypair;
 	return $keypair;
 }
@@ -63,9 +61,9 @@ function decode_public_key( string $key ) : KeyPair {
  *
  * @throws Exception If the curve is not supported.
  * @param string $key The multibase public key string (starts with z).
- * @return KeyPair The keypair object.
+ * @return Key The key object.
  */
-function decode_private_key( string $key ) : KeyPair {
+function decode_private_key( string $key ) : Key {
 	static $cache = [];
 	if ( isset( $cache[ $key ] ) ) {
 		return $cache[ $key ];
@@ -73,16 +71,17 @@ function decode_private_key( string $key ) : KeyPair {
 
 	$decoded = Multibase::decode( $key );
 
-	$curve = match ( $decoded[0] ) {
-		"\x80" => CURVE_P256,
-		"\xE7" => CURVE_K256,
+	$keypair = match ( substr( $decoded, 0, 2 ) ) {
+		PREFIX_CURVE_P256_PRIVATE => ECKey::from_private( $key ),
+		PREFIX_CURVE_K256_PRIVATE => ECKey::from_private( $key ),
+		PREFIX_CURVE_ED25519_PRIVATE => EdDSAKey::from_private( $key ),
+
+		// todo: Legacy, remove this later.
+		PREFIX_CURVE_P256    => ECKey::from_private( $key ),
+		PREFIX_CURVE_K256    => ECKey::from_private( $key ),
+		PREFIX_CURVE_ED25519 => EdDSAKey::from_private( $key ),
 		default => throw new Exception( 'Unsupported curve' ),
 	};
-
-	$ec = new EC( $curve );
-
-	$stripped = bin2hex( substr( $decoded, 2 ) );
-	$keypair = $ec->keyFromPrivate( $stripped, 'hex' );
 	$cache[ $key ] = $keypair;
 	return $keypair;
 }
@@ -92,9 +91,9 @@ function decode_private_key( string $key ) : KeyPair {
  *
  * @throws Exception If the did:key: string is invalid.
  * @param string $did The did:key: string.
- * @return KeyPair The keypair object.
+ * @return Key The key object.
  */
-function decode_did_key( string $did ) : KeyPair {
+function decode_did_key( string $did ) : Key {
 	if ( ! str_starts_with( $did, 'did:key:' ) ) {
 		throw new Exception( 'Invalid DID format' );
 	}
@@ -106,59 +105,14 @@ function decode_did_key( string $did ) : KeyPair {
 	return decode_public_key( $did );
 }
 
-/**
- * Convert a keypair object to a multibase public key string.
- *
- * @see https://atproto.com/specs/cryptography
- *
- * @throws Exception If the curve is not supported.
- * @param KeyPair $key The keypair object.
- * @param string $curve The curve to use (CURVE_K256 or CURVE_P256).
- * @return string The multibase public key string (starts with z).
- */
-function encode_public_key( KeyPair $key, string $curve ) : string {
-	$pub = $key->getPublic( true, 'hex' );
-	$prefix = match ( $curve ) {
-		CURVE_K256 => 'e701',
-		CURVE_P256 => '8024',
-		default => throw new Exception( 'Unsupported curve' ),
-	};
-
-	$encoded = Multibase::encode( Multibase::BASE58BTC, hex2bin( $prefix . $pub ) );
-	return $encoded;
-}
-
-/**
- * Convert a keypair object to a multibase private key string.
- *
- * @see https://atproto.com/specs/cryptography
- *
- * @throws Exception If the curve is not supported.
- * @param KeyPair $key The keypair object.
- * @param string $curve The curve to use (CURVE_K256 or CURVE_P256).
- * @return string The multibase private key string (starts with z).
- */
-function encode_private_key( KeyPair $key, string $curve ) : string {
-	$priv = $key->getPrivate( 'hex' );
-	$prefix = match ( $curve ) {
-		CURVE_K256 => 'E701',
-		CURVE_P256 => '8024',
-		default => throw new Exception( 'Unsupported curve' ),
-	};
-
-	$encoded = Multibase::encode( Multibase::BASE58BTC, hex2bin( $prefix . $priv ));
-	return $encoded;
-}
-
 /**
  * Convert a keypair object to a did:key: string.
  *
  * @throws Exception If the curve is not supported.
- * @param KeyPair $key The keypair object.
+ * @param Key $key The keypair object.
  * @param string $curve The curve to use (CURVE_K256 or CURVE_P256).
  * @return string The did:key: string.
  */
-function encode_did_key( KeyPair $key, string $curve ) : string {
-	$encoded = encode_public_key( $key, $curve );
-	return 'did:key:' . $encoded;
+function encode_did_key( Key $key ) : string {
+	return 'did:key:' . $key->encode_public();
 }
diff --git a/inc/plc/class-canonicalmapobject.php b/inc/plc/class-canonicalmapobject.php
index abc93bb..69a5a66 100644
--- a/inc/plc/class-canonicalmapobject.php
+++ b/inc/plc/class-canonicalmapobject.php
@@ -63,12 +63,14 @@ public function __construct(array $data = [])
 
     public function __toString(): string
     {
-        uksort($this->data, function ($a, $b) {
-            if (strlen($a) === strlen($b) ) {
-                return strcmp($a, $b);
+        usort($this->data, function ($a, $b) {
+            $a_key = (string) $a->getKey();
+            $b_key = (string) $b->getKey();
+            if (strlen($a_key) === strlen($b_key) ) {
+                return strcmp($a_key, $b_key);
             }
 
-            return strlen($a) <=> strlen($b);
+            return strlen($a_key) <=> strlen($b_key);
         });
 
         $result = parent::__toString();
diff --git a/inc/plc/class-command.php b/inc/plc/class-command.php
index 767762f..cabd76a 100644
--- a/inc/plc/class-command.php
+++ b/inc/plc/class-command.php
@@ -20,7 +20,7 @@ public function generate( $args, $assoc_args ) {
 
 		$rot_keys = $did->get_rotation_keys();
 		foreach ( $rot_keys as $key ) {
-			$encoded = Keys\encode_public_key( $key, Keys\CURVE_K256 );
+			$encoded = $key->encode_public();
 			printf(
 				"Rotation key:     %s\n",
 				$encoded
@@ -28,7 +28,7 @@ public function generate( $args, $assoc_args ) {
 		}
 		$verif_keys = $did->get_verification_keys();
 		foreach ( $verif_keys as $key ) {
-			$encoded = Keys\encode_public_key( $key, Keys\CURVE_K256 );
+			$encoded = $key->encode_public();
 			printf(
 				"Verification key: %s\n",
 				$encoded
@@ -48,7 +48,7 @@ public function get( $args, $assoc_args ) {
 
 		$rot_keys = $did->get_rotation_keys();
 		foreach ( $rot_keys as $key ) {
-			$encoded = Keys\encode_public_key( $key, Keys\CURVE_K256 );
+			$encoded = $key->encode_public();
 			printf(
 				"Rotation key:     %s\n",
 				$encoded
@@ -56,7 +56,7 @@ public function get( $args, $assoc_args ) {
 		}
 		$verif_keys = $did->get_verification_keys();
 		foreach ( $verif_keys as $key ) {
-			$encoded = Keys\encode_public_key( $key, Keys\CURVE_K256 );
+			$encoded = $key->encode_public();
 			printf(
 				"Verification key: %s\n",
 				$encoded
diff --git a/inc/plc/class-did.php b/inc/plc/class-did.php
index 5db7502..e888c5d 100644
--- a/inc/plc/class-did.php
+++ b/inc/plc/class-did.php
@@ -2,11 +2,12 @@
 
 namespace MiniFAIR\PLC;
 
-use Elliptic\EC\KeyPair;
 use Exception;
 use MiniFAIR;
 use MiniFAIR\API;
 use MiniFAIR\Keys;
+use MiniFAIR\Keys\Key;
+use stdClass;
 use WP_Post;
 
 class DID {
@@ -41,19 +42,63 @@ class DID {
 	protected ?string $prev = null;
 
 	/**
-	 * @return KeyPair[]
+	 * @return Keys\ECKey[]
 	 */
 	public function get_rotation_keys() : array {
 		return array_map( fn ( $key ) => Keys\decode_private_key( $key ), $this->rotation_keys );
 	}
 
 	/**
-	 * @return KeyPair[]
+	 * @return Keys\EdDSAKey[]
 	 */
 	public function get_verification_keys() : array {
 		return array_map( fn ( $key ) => Keys\decode_private_key( $key ), $this->verification_keys );
 	}
 
+	/**
+	 * Invalidate a verification key.
+	 *
+	 * Note that update() must be called to persist the change.
+	 *
+	 * @param Key $key The key to invalidate.
+	 * @return bool True if the key was invalidated, false if it was not found.
+	 */
+	public function invalidate_verification_key( Key $key ) {
+		$encoded = $key->encode_private();
+
+		if ( ! in_array( $encoded, $this->verification_keys, true ) ) {
+			// Check for legacy-encoded keys too.
+			if ( method_exists( $key, 'encode_private_legacy_do_not_use_or_you_will_be_fired' ) ) {
+				$legacy_encoded = $key->encode_private_legacy_do_not_use_or_you_will_be_fired();
+				if ( ! in_array( $legacy_encoded, $this->verification_keys, true ) ) {
+					return false;
+				}
+				$encoded = $legacy_encoded;
+			}
+			else {
+				return false;
+			}
+		}
+
+		$this->verification_keys = array_values( array_filter( $this->verification_keys, fn ( $k ) => $k !== $encoded ) );
+		return true;
+	}
+
+	/**
+	 * Generate a new verification key.
+	 *
+	 * Creates a new EdDSA (Ed25519) keypair, and adds it to key list.
+	 *
+	 * Note that update() must be called to persist the change.
+	 *
+	 * @return Key The generated key.
+	 */
+	public function generate_verification_key() : Key {
+		$key = Keys\EdDSAKey::generate( Keys\CURVE_ED25519 );
+		$this->verification_keys[] = $key->encode_private();
+		return $key;
+	}
+
 	/**
 	 * Get the internal post ID for this DID.
 	 *
@@ -111,7 +156,7 @@ protected function perform_operation( SignedOperation $op ) {
 			throw new \Exception( 'Error performing operation: ' . wp_remote_retrieve_body( $response ) );
 		}
 
-		var_dump( $response );
+		return true;
 	}
 
 	public function update() {
@@ -125,6 +170,30 @@ public function update() {
 		return $this->perform_operation( $op );
 	}
 
+	public function get_expected_document() : array {
+		$op = $this->prepare_update_op();
+		if ( ! $op ) {
+			$op = $this->fetch_last_op();
+		}
+
+		// Convert the operation to a document.
+		return operation_to_did_document( $this->id, $op );
+	}
+
+	/**
+	 * Prepare the verification keys for the operation.
+	 *
+	 * Generates a unique ID for each key, using its hash.
+	 */
+	protected function get_verification_keys_for_op() : array {
+		$verification_keys = [];
+		foreach ( $this->get_verification_keys() as $key ) {
+			$key_id = substr( hash( 'sha256', $key->encode_public() ), 0, 6 );
+			$verification_keys[ 'fair_' . $key_id ] = $key;
+		}
+		return $verification_keys;
+	}
+
 	protected function prepare_update_op() : ?SignedOperation {
 		// Fetch the previous op.
 		$last_op = $this->fetch_last_op();
@@ -136,9 +205,7 @@ protected function prepare_update_op() : ?SignedOperation {
 		$update_unsigned = new Operation(
 			type: 'plc_operation',
 			rotationKeys: $this->get_rotation_keys(),
-			verificationMethods: [
-				VERIFICATION_METHOD_ID => $this->get_verification_keys()[0],
-			],
+			verificationMethods: $this->get_verification_keys_for_op(),
 			alsoKnownAs: $last_op->alsoKnownAs,
 			services: [
 				'fairpm_repo' => [
@@ -237,6 +304,37 @@ public function is_published() {
 	 */
 	protected bool $created = false;
 
+	public function export() : stdClass {
+		return (object) [
+			'@context' => 'https://fair.pm/did-export',
+			'_warning' => 'WARNING: This file contains your private keys for your DID. Do not share it publicly, as it will lead to your DID being PERMANENTLY COMPROMISED and UNRECOVERABLE.',
+			'id' => $this->id,
+			'rotation' => array_values( $this->rotation_keys ),
+			'verification' => array_values( $this->verification_keys ),
+		];
+	}
+
+	public static function import( stdClass $data ) {
+		if ( empty( $data->{'@context'} ) || $data->{'@context'} !== 'https://fair.pm/did-export' ) {
+			throw new Exception( 'Invalid DID export data.', 400 );
+		}
+
+		$did = new static();
+		$did->id = $data->id;
+
+		// Check that we can decode the keys we're passed.
+		foreach ( $data->rotation as $key ) {
+			Keys\decode_private_key( $key );
+			$did->rotation_keys[] = $key;
+		}
+		foreach ( $data->verification as $key ) {
+			Keys\decode_private_key( $key );
+			$did->verification_keys[] = $key;
+		}
+
+		return $did;
+	}
+
 	public static function get( string $id ) {
 		$did = new self();
 		$did->id = $id;
@@ -273,18 +371,13 @@ public static function create() {
 		$did = new self();
 
 		// Generate an initial keypair for rotation.
-		$rotation_key = Keys\generate_keypair();
-		$encoded_rotation_key = Keys\encode_private_key( $rotation_key, Keys\CURVE_K256 );
+		$rotation_key = Keys\ECKey::generate( Keys\CURVE_K256 );
 		$did->rotation_keys = [
-			$encoded_rotation_key,
+			$rotation_key->encode_private(),
 		];
 
 		// Generate an initial keypair for verification.
-		$verification_key = Keys\generate_keypair();
-		$encoded_verification_key = Keys\encode_private_key( $verification_key, Keys\CURVE_K256 );
-		$did->verification_keys = [
-			$encoded_verification_key,
-		];
+		$did->generate_verification_key();
 
 		// Create the genesis operation.
 		$genesis_unsigned = new Operation(
@@ -292,24 +385,9 @@ public static function create() {
 			rotationKeys: [
 				$rotation_key,
 			],
-			verificationMethods: [
-				VERIFICATION_METHOD_ID => $verification_key,
-				// 'atproto' => $verification_key,
-			],
+			verificationMethods: $did->get_verification_keys_for_op(),
 			alsoKnownAs: [],
 			services: [],
-			// 'services' => [
-			// 	'fairpm_repo' => [
-			// 		'serviceEndpoint' => 'https://fairpm.example.com/repo',
-			// 		'type' => 'FairPackageManagementRepo',
-			// 	],
-			// ],
-			// services: [
-			// 	'atproto_pds' => [
-			// 		'endpoint' => 'https://example.com/pds',
-			// 		'type' => 'AtprotoPersonalDataServer',
-			// 	],
-			// ],
 		);
 
 		// Sign the op, then generate the DID from it.
diff --git a/inc/plc/class-operation.php b/inc/plc/class-operation.php
index 45032c1..e716e56 100644
--- a/inc/plc/class-operation.php
+++ b/inc/plc/class-operation.php
@@ -2,8 +2,8 @@
 
 namespace MiniFAIR\PLC;
 
-use Elliptic\EC\KeyPair;
 use MiniFAIR\Keys;
+use MiniFAIR\Keys\Key;
 use Exception;
 use JsonSerializable;
 
@@ -62,21 +62,21 @@ public function validate() : bool {
 		if ( empty( $this->rotationKeys ) ) {
 			throw new Exception( 'Rotation keys are empty' );
 		}
-		foreach ( $this->rotationKeys as $keypair ) {
-			if ( ! $keypair instanceof KeyPair ) {
-				throw new Exception( 'Rotation key is not a KeyPair object' );
+		foreach ( $this->rotationKeys as $key ) {
+			if ( ! $key instanceof Key ) {
+				throw new Exception( 'Rotation key is not a Key object' );
 			}
 		}
 
 		if ( empty( $this->verificationMethods ) ) {
 			throw new Exception( 'Verification methods are empty' );
 		}
-		foreach ( $this->verificationMethods as $key => $keypair ) {
-			if ( $key !== VERIFICATION_METHOD_ID ) {
-				throw new Exception( sprintf( 'Invalid verification method ID: %s', $key ) );
+		foreach ( $this->verificationMethods as $id => $key ) {
+			if ( ! str_starts_with( $id, VERIFICATION_METHOD_PREFIX ) ) {
+				throw new Exception( sprintf( 'Invalid verification method ID: %s', $id ) );
 			}
-			if ( ! $keypair instanceof KeyPair ) {
-				throw new Exception( 'Rotation key is not a KeyPair object' );
+			if ( ! $key instanceof Key ) {
+				throw new Exception( 'Rotation key is not a Key object' );
 			}
 		}
 
@@ -85,7 +85,7 @@ public function validate() : bool {
 			if ( empty( $this->rotationKeys ) || empty( $this->verificationMethods ) ) {
 				throw new Exception( 'Missing rotationKeys or verificationMethods' );
 			}
-			if ( empty( $this->verificationMethods[ VERIFICATION_METHOD_ID ] ) ) {
+			if ( empty( $this->verificationMethods ) ) {
 				throw new Exception( 'Missing verification method for FAIR' );
 			}
 		}
@@ -93,7 +93,7 @@ public function validate() : bool {
 		return true;
 	}
 
-	public function sign( KeyPair $rotation_key ) : SignedOperation {
+	public function sign( Key $rotation_key ) : SignedOperation {
 		return sign_operation( $this, $rotation_key );
 	}
 
diff --git a/inc/plc/namespace.php b/inc/plc/namespace.php
index 244243d..e053017 100644
--- a/inc/plc/namespace.php
+++ b/inc/plc/namespace.php
@@ -8,17 +8,13 @@
 	TextStringObject,
 };
 use CBOR\OtherObject\NullObject;
-use Elliptic\EC;
-use Elliptic\EC\KeyPair;
-use Elliptic\EC\Signature;
-use Elliptic\Utils;
 use MiniFAIR\Admin;
 use MiniFAIR\Keys;
-use Exception;
+use MiniFAIR\Keys\Key;
 use WP_CLI;
 use YOCLIB\Multiformats\Multibase\Multibase;
 
-const VERIFICATION_METHOD_ID = 'fairpm';
+const VERIFICATION_METHOD_PREFIX = 'fair_';
 
 function bootstrap() {
 	add_action( 'init', __NAMESPACE__ . '\\register_types' );
@@ -48,50 +44,25 @@ function register_types() {
 	] );
 }
 
-/**
- * Convert a signature to compact (IEEE-P1363) representation.
- *
- * (Equivalent to secp256k1_ecdsa_sign_compact().)
- *
- * @internal Elliptic does not support compact signatures, only DER-encoded, so
- *           we need to do it ourselves. Compact signatures are just the r and
- *           s bytes concatenated, but must be padded to 32 bytes each.
- *
- * @param EC $ec The elliptic curve object.
- * @param Signature $signature The signature object.
- * @return string The compact signature.
- */
-function signature_to_compact( EC $ec, Signature $signature ) : string {
-	$byte_length = ceil( $ec->curve->n->bitLength() / 8);
-	$compact = Utils::toHex( $signature->r->toArray( 'be', $byte_length ) ) . Utils::toHex( $signature->s->toArray( 'be', $byte_length ) );
-	return $compact;
-}
-
 /**
  * Sign an operation.
  *
  * @param Operation $data The operation to sign.
- * @param KeyPair $signing_key The signing key.
+ * @param Key $signing_key The signing key.
  * @return SignedOperation The signed operation.
  */
-function sign_operation( Operation $data, KeyPair $signing_key ) : SignedOperation {
+function sign_operation( Operation $data, Key $key ) : SignedOperation {
 	// Validate the operation.
 	$data->validate();
 
 	// Encode the operation into DAG-CBOR.
 	$encoded = encode_operation( $data );
 
-	/**
-	 * Hash with SHA-256, then sign, using canonical (low-S) form.
-	 *
-	 * @var \Elliptic\EC\Signature
-	 */
-	$signature = $signing_key->sign( hash( 'sha256', $encoded, false ), 'hex', [
-		'canonical' => true
-	] );
+	// Sign the hash of the data.
+	$signature = $key->sign( hash( 'sha256', $encoded, false ) );
 
-	// Convert to compact (IEEE-P1363) form, then to base64url.
-	$sig_string = Util\base64url_encode( hex2bin( signature_to_compact( $signing_key->ec, $signature ) ) );
+	// Convert to base64url.
+	$sig_string = Util\base64url_encode( hex2bin( $signature ) );
 
 	return new SignedOperation( $data, $sig_string );
 }
@@ -129,13 +100,13 @@ function encode_operation( Operation $data ) : string {
 		)
 		->add(
 			TextStringObject::create( 'rotationKeys' ),
-			ListObject::create( array_map( fn ( KeyPair $key ) => TextStringObject::create( Keys\encode_did_key( $key, Keys\CURVE_K256 ) ), $data->rotationKeys ) )
+			ListObject::create( array_map( fn ( Key $key ) => TextStringObject::create( Keys\encode_did_key( $key ) ), $data->rotationKeys ) )
 		)
 		->add(
 			TextStringObject::create( 'verificationMethods' ),
-			CanonicalMapObject::create( array_map( fn ( string $key, KeyPair $value ) => MapItem::create(
+			CanonicalMapObject::create( array_map( fn ( string $key, Key $value ) => MapItem::create(
 				TextStringObject::create( $key ),
-				TextStringObject::create( Keys\encode_did_key( $value, Keys\CURVE_K256 ) )
+				TextStringObject::create( Keys\encode_did_key( $value ) )
 			), array_keys( $data->verificationMethods ), $data->verificationMethods ) )
 		);
 
@@ -215,3 +186,46 @@ function cid_for_operation( SignedOperation $op ) : string {
 	$cid = Multibase::encode( Multibase::BASE32, $cid );
 	return $cid;
 }
+
+/**
+ * Convert an operation to an expected DID Document.
+ *
+ * Used to predict the output DID document after an operation is performed.
+ * This should only be used for informational purposes, such as displaying an
+ * indicative diff to a user.
+ *
+ * @param string $id DID ID.
+ * @param Operation $op The operation to convert.
+ * @return array The DID Document representation of the operation.
+ */
+function operation_to_did_document( string $id, Operation $op ) : array {
+	$doc = [
+		'id' => $id,
+		'alsoKnownAs' => $op->alsoKnownAs,
+		'verificationMethod' => [],
+		'service' => [],
+	];
+
+	foreach ( $op->verificationMethods as $key => $value ) {
+		if ( ! empty( $value ) ) {
+			$doc['verificationMethod'][] = [
+				'id' => sprintf( '%s#%s', $id, $key ),
+				'type' => 'Multikey',
+				'controller' => $id,
+				'publicKeyMultibase' => $value->encode_public(),
+			];
+		}
+	}
+
+	foreach ( $op->services as $key => $service ) {
+		if ( ! empty( $service['endpoint'] ) && ! empty( $service['type'] ) ) {
+			$doc['service'][] = [
+				'id' => sprintf( '#%s', $key ),
+				'type' => $service['type'],
+				'serviceEndpoint' => $service['endpoint'],
+			];
+		}
+	}
+
+	return $doc;
+}