fix: address review comments

packages/interface/src/lib.ts

@@ -389,22 +389,61 @@ export interface PrincipalParser {
   parse(did: UCAN.DID): Verifier
 }
 
-export interface IntoSigner {
-  decode: (bytes: Uint8Array) => Signer
+/**
+ * Represents component that can create a signer from it's archive. Usually
+ * signer module would provide `from` function and therefor be implementation
+ * of this interface.
+ * Library also provides utility functions for combining multiple
+ * SignerImporters into one.
+ */
+export interface SignerImporter<Self extends Signer = Signer> {
+  from(archive: SignerArchive<Self>): Self
 }
 
 export interface Signer<M extends string = string, A extends number = number>
   extends UCANSigner<M, A> {
-  export?: () => Await<ByteView<Signer<M, A>>>
-  toCryptoKey?: () => Await<CryptoKey>
+  /**
+   * Returns archive of this signer which is byte encoded form when signer key
+   * is extractable and is {@link SignerInfo} form otherwise. This allows a user
+   * to store non extractable archives in indexedDB and store extractable
+   * archives on disk, which matches general expectation that in browsers
+   * unextratable keys should be used and extractable keys in node.
+   *
+   * @example
+   * ```ts
+   * const save = async (signer: Signer) => {
+   *   const archive = signer.toAchive()
+   *   if (archive instanceof Uint8Array) {
+   *     await fs.writeFile(KEY_PATH, archive)
+   *   } else (signer.exportKey) {
+   *     await IDB_OBJECT_STORE.add(archive)
+   *   }
+   * }
+   * ```
+   */
+  toArchive(): SignerArchive<Signer<M, A>>
 }
 
+export interface SignerInfo<Self extends Signer = Signer> {
+  readonly did: ReturnType<Self['did']>
+  readonly key: CryptoKey
+}
+
+export type SignerArchive<Self extends Signer = Signer> =
+  | ByteView<Self>
+  | SignerInfo<Self>
+
 export interface Verifier<M extends string = string, A extends number = number>
   extends UCANVerifier<M, A> {
-  export?: () => Await<ByteView<Verifier<M, A>>>
-  toCryptoKey?: () => Await<CryptoKey>
+  format(): DID<M>
 }
 
 export type InferInvokedCapability<
   C extends CapabilityParser<Match<ParsedCapability>>
 > = C extends CapabilityParser<Match<infer T>> ? T : never
+
+export type Intersection<T> = (T extends any ? (i: T) => void : never) extends (
+  i: infer I
+) => void
+  ? I
+  : never

packages/principal/src/ed25519/signer.js

@@ -2,7 +2,7 @@ import * as ED25519 from '@noble/ed25519'
 import { varint } from 'multiformats'
 import * as API from './type.js'
 import * as Verifier from './verifier.js'
-import { base64pad, base64url } from 'multiformats/bases/base64'
+import { base64pad } from 'multiformats/bases/base64'
 import * as Signature from '@ipld/dag-ucan/signature'
 
 export const code = 0x1300
@@ -47,6 +47,18 @@ export const derive = async secret => {
   return signer
 }
 
+/**
+ * @param {API.SignerArchive<API.Signer<"key", typeof signatureCode>>} archive
+ * @returns {API.EdSigner}
+ */
+export const from = archive => {
+  if (archive instanceof Uint8Array) {
+    return decode(archive)
+  } else {
+    throw new Error(`Unsupported archive format`)
+  }
+}
+
 /**
  * @param {Uint8Array} bytes
  * @returns {API.EdSigner}
@@ -81,15 +93,15 @@ export const decode = bytes => {
  * @param {API.EdSigner} signer
  * @return {API.ByteView<API.EdSigner>}
  */
-export const encode = signer => signer.encode()
+export const encode = signer => signer.toArchive()
 
 /**
  * @template {string} Prefix
  * @param {API.EdSigner} signer
  * @param {API.MultibaseEncoder<Prefix>} [encoder]
  */
 export const format = (signer, encoder) =>
-  (encoder || base64pad).encode(signer.encode())
+  (encoder || base64pad).encode(encode(signer))
 
 /**
  * @template {string} Prefix
@@ -173,10 +185,7 @@ class Ed25519Signer extends Uint8Array {
     return Signature.EdDSA
   }
 
-  export() {
-    return this
-  }
-  encode() {
+  toArchive() {
     return this
   }
 }

packages/principal/src/ed25519/type.ts

@@ -13,7 +13,7 @@ export interface EdSigner<M extends string = 'key'>
   readonly verifier: EdVerifier<M>
 
   readonly code: 0x1300
-  encode(): ByteView<EdSigner<M>>
+  toArchive(): ByteView<EdSigner<M>>
 }
 
 export interface EdVerifier<M extends string = 'key'>

packages/principal/src/ed25519/verifier.js

@@ -110,8 +110,8 @@ class Ed25519Verifier extends Uint8Array {
     )
   }
 
-  export() {
-    return this
+  format() {
+    return this.did()
   }
   encode() {
     return this