iso-signatures 0.1.10 → 0.3.0

package/dist/src/index.d.ts

@@ -1 +1,2 @@
+export {};
 //# sourceMappingURL=index.d.ts.map

package/dist/src/signers/ecdsa.d.ts

@@ -13,31 +13,28 @@ export class ECDSASigner implements ISigner {
     /**
      * Import a signer from a JWK
      *
-     * @param {import('../types.js').PrivateKeyJwk} jwk
+     * @param {import('iso-did/types').ECJWKPrivate} jwk
+     * @param {import('iso-did/types').VerifiableDID} [did]
      */
-    static importJwk(jwk: import('../types.js').PrivateKeyJwk): Promise<ECDSASigner>;
+    static importJwk(jwk: import('iso-did/types').ECJWKPrivate, did?: import("iso-did/types").VerifiableDID | undefined): Promise<ECDSASigner>;
     /**
      * Import a signer from a CryptoKeyPair
      *
      * @param {CryptoKeyPair} key
+     * @param {import('iso-did/types').VerifiableDID} [did]
      */
-    static import(key: CryptoKeyPair): Promise<ECDSASigner>;
+    static import(key: CryptoKeyPair, did?: import("iso-did/types").VerifiableDID | undefined): Promise<ECDSASigner>;
     /**
-     * @param {ECDSAAlg} alg
-     * @param {Uint8Array} publicKey
+     * @param {import('iso-did/types').VerifiableDID} did
      * @param {CryptoKeyPair} keypair
      */
-    constructor(alg: ECDSAAlg, publicKey: Uint8Array, keypair: CryptoKeyPair);
-    params: {
-        name: "ECDSA";
-        namedCurve: "P-256" | "P-384" | "P-521";
-        hash: "SHA-256" | "SHA-384" | "SHA-512";
-    };
-    keypair: CryptoKeyPair;
+    constructor(did: import('iso-did/types').VerifiableDID, keypair: CryptoKeyPair);
+    did: `did:${string}:${string}`;
+    url: import("iso-did/types").DIDURLObject;
+    type: "P-256" | "P-384" | "P-521" | "Ed25519" | "secp256k1" | "RSA";
     publicKey: Uint8Array;
     alg: "ES256" | "ES384" | "ES512";
-    type: "P-256" | "P-384" | "P-521";
-    did: DIDKey;
+    document: import("iso-did/types").DIDDocument;
     /**
      * Sign a message
      *
@@ -50,8 +47,9 @@ export class ECDSASigner implements ISigner {
      * @returns {CryptoKeyPair}
      */
     export(): CryptoKeyPair;
+    toString(): string;
+    #private;
 }
 export type ISigner = import('../types.js').ISigner<CryptoKeyPair>;
 export type ECDSAAlg = Extract<import('iso-did/types').SignatureAlgorithm, 'ES256' | 'ES384' | 'ES512'>;
-import { DIDKey } from 'iso-did/key';
 //# sourceMappingURL=ecdsa.d.ts.map

package/dist/src/signers/ecdsa.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ecdsa.d.ts","sourceRoot":"","sources":["../../../src/signers/ecdsa.js"],"names":[],"mappings":"AAqBA;;;;GAIG;AACH;IAeE;;;;OAIG;IACH,qBAFW,QAAQ,wBAelB;IAED;;;;OAIG;IACH,sBAFW,OAAO,aAAa,EAAE,aAAa,wBA0B7C;IAED;;;;OAIG;IACH,mBAFW,aAAa,wBA0BvB;IA9FD;;;;OAIG;IACH,iBAJW,QAAQ,aACR,UAAU,WACV,aAAa,EASvB;IANC;;;;MAAoC;IACpC,uBAAsB;IACtB,sBAA0B;IAC1B,iCAAc;IACd,kCAAkC;IAClC,YAA0D;IAqF5D;;;;OAIG;IACH,cAFW,UAAU,uBAUpB;IAED;;;;OAIG;IACH,UAFa,aAAa,CAIzB;CACF;sBA3IY,OAAO,aAAa,EAAE,OAAO,CAAC,aAAa,CAAC;uBAC5C,QAAQ,OAAO,eAAe,EAAE,kBAAkB,EAAE,OAAO,GAAG,OAAO,GAAG,OAAO,CAAC;uBALxD,aAAa"}
+{"version":3,"file":"ecdsa.d.ts","sourceRoot":"","sources":["../../../src/signers/ecdsa.js"],"names":[],"mappings":"AAoBA;;;;GAIG;AACH;IAqBE;;;;OAIG;IACH,qBAFW,QAAQ,wBAkBlB;IAED;;;;;OAKG;IACH,sBAHW,OAAO,eAAe,EAAE,YAAY,iFA4B9C;IAED;;;;;OAKG;IACH,mBAHW,aAAa,iFA+BvB;IAzGD;;;OAGG;IACH,iBAHW,OAAO,eAAe,EAAE,aAAa,WACrC,aAAa,EAWvB;IARC,+BAAkB;IAClB,0CAAkB;IAClB,oEAAoB;IACpB,sBAA8B;IAC9B,iCAA8B;IAC9B,8CAA4B;IAiG9B;;;;OAIG;IACH,cAFW,UAAU,uBAUpB;IAED;;;;OAIG;IACH,UAFa,aAAa,CAIzB;IAED,mBAEC;;CACF;sBA/JY,OAAO,aAAa,EAAE,OAAO,CAAC,aAAa,CAAC;uBAC5C,QAAQ,OAAO,eAAe,EAAE,kBAAkB,EAAE,OAAO,GAAG,OAAO,GAAG,OAAO,CAAC"}

package/dist/src/signers/eddsa.d.ts

@@ -1,6 +1,3 @@
-/**
- * @typedef {import('../types.js').ISigner<string>} ISigner
- */
 /**
  * EdDSA signer
  *
@@ -22,19 +19,20 @@ export class EdDSASigner implements ISigner {
      * Import a signer from a encoded string
      *
      * @param {string} encoded
+     * @param {import('iso-did/types').VerifiableDID} [did]
      */
-    static import(encoded: string): Promise<EdDSASigner>;
+    static import(encoded: string, did?: import("iso-did/types").VerifiableDID | undefined): Promise<EdDSASigner>;
     /**
-     * @param {Uint8Array} publicKey
+     * @param {import('iso-did/types').VerifiableDID} did
      * @param {Uint8Array} privateKey
      */
-    constructor(publicKey: Uint8Array, privateKey: Uint8Array);
-    privateKey: Uint8Array;
+    constructor(did: import('iso-did/types').VerifiableDID, privateKey: Uint8Array);
+    did: `did:${string}:${string}`;
+    url: import("iso-did/types").DIDURLObject;
+    type: "P-256" | "P-384" | "P-521" | "Ed25519" | "secp256k1" | "RSA";
     publicKey: Uint8Array;
-    alg: "EdDSA";
-    type: "Ed25519";
-    code: number;
-    did: DIDKey;
+    alg: "EdDSA" | "ES256" | "ES384" | "ES512" | "ES256K" | "RS256";
+    document: import("iso-did/types").DIDDocument;
     /**
      * Sign a message
      *
@@ -45,7 +43,8 @@ export class EdDSASigner implements ISigner {
      * Export the signer as a encoded string
      */
     export(): string;
+    toString(): string;
+    #private;
 }
 export type ISigner = import('../types.js').ISigner<string>;
-import { DIDKey } from 'iso-did/key';
 //# sourceMappingURL=eddsa.d.ts.map

package/dist/src/signers/eddsa.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"eddsa.d.ts","sourceRoot":"","sources":["../../../src/signers/eddsa.js"],"names":[],"mappings":"AAUA;;GAEG;AAEH;;;;GAIG;AACH;IACE,2EAA2E;IAC3E,YADW,QAAQ,OAAO,eAAe,EAAE,kBAAkB,EAAE,OAAO,CAAC,CACnD;IAEpB,kEAAkE;IAClE,aADW,QAAQ,OAAO,eAAe,EAAE,OAAO,EAAE,SAAS,CAAC,CACvC;IAEvB,oBAAoB;IAepB;;;;OAIG;IACH,sEAIC;IAED;;;;OAIG;IACH,uBAFW,MAAM,wBAOhB;IAlCD;;;OAGG;IACH,uBAHW,UAAU,cACV,UAAU,EASpB;IANC,uBAA4B;IAC5B,sBAA0B;IAC1B,aAA0B;IAC1B,gBAA4B;IAC5B,aAA4B;IAC5B,YAAiE;IA0BnE;;;;OAIG;IACH,cAFW,UAAU,uBAIpB;IAED;;OAEG;IACH,iBAEC;CACF;sBApEY,OAAO,aAAa,EAAE,OAAO,CAAC,MAAM,CAAC;uBAN3B,aAAa"}
+{"version":3,"file":"eddsa.d.ts","sourceRoot":"","sources":["../../../src/signers/eddsa.js"],"names":[],"mappings":"AA4BA;;;;GAIG;AACH;IACE,2EAA2E;IAC3E,YADW,QAAQ,OAAO,eAAe,EAAE,kBAAkB,EAAE,OAAO,CAAC,CACnD;IAEpB,kEAAkE;IAClE,aADW,QAAQ,OAAO,eAAe,EAAE,OAAO,EAAE,SAAS,CAAC,CACvC;IAEvB,oBAAoB;IAoBpB;;;;OAIG;IACH,sEAOC;IAED;;;;;OAKG;IACH,uBAHW,MAAM,iFAWhB;IA3CD;;;OAGG;IACH,iBAHW,OAAO,eAAe,EAAE,aAAa,cACrC,UAAU,EAWpB;IAPC,+BAAkB;IAClB,0CAAkB;IAClB,oEAAoB;IACpB,sBAA8B;IAC9B,gEAAkB;IAClB,8CAA4B;IAkC9B;;;;OAIG;IACH,cAFW,UAAU,uBAIpB;IAED;;OAEG;IACH,iBAEC;IAED,mBAEC;;CACF;sBAjGY,OAAO,aAAa,EAAE,OAAO,CAAC,MAAM,CAAC"}

package/dist/src/signers/rsa.d.ts

@@ -1,6 +1,3 @@
-/**
- * @typedef {import('../types.js').ISigner<CryptoKeyPair>} ISigner
- */
 /**
  * RSA signer
  *
@@ -19,26 +16,28 @@ export class RSASigner implements ISigner {
     /**
      * Import a signer from a JWK
      *
-     * @param {import('../types.js').PrivateKeyRSAJwk} jwk
+     * @param {import('iso-did/types').RSAJWKPrivate} jwk
+     * @param {import('iso-did/types').VerifiableDID} [did]
      */
-    static importJwk(jwk: import('../types.js').PrivateKeyRSAJwk): Promise<RSASigner>;
+    static importJwk(jwk: import('iso-did/types').RSAJWKPrivate, did?: import("iso-did/types").VerifiableDID | undefined): Promise<RSASigner>;
     /**
      * Import a signer from a keypair
      *
      * @param {CryptoKeyPair} keypair
+     * @param {import('iso-did/types').VerifiableDID} [did]
      */
-    static import(keypair: CryptoKeyPair): Promise<RSASigner>;
+    static import(keypair: CryptoKeyPair, did?: import("iso-did/types").VerifiableDID | undefined): Promise<RSASigner>;
     /**
-     * @param {Uint8Array} publicKey
+     * @param {import('iso-did/types').VerifiableDID} did
      * @param {CryptoKeyPair} keypair
      */
-    constructor(publicKey: Uint8Array, keypair: CryptoKeyPair);
-    keypair: CryptoKeyPair;
+    constructor(did: import('iso-did/types').VerifiableDID, keypair: CryptoKeyPair);
+    did: `did:${string}:${string}`;
+    url: import("iso-did/types").DIDURLObject;
+    type: "P-256" | "P-384" | "P-521" | "Ed25519" | "secp256k1" | "RSA";
     publicKey: Uint8Array;
-    alg: "RS256";
-    type: "RSA";
-    code: number;
-    did: DIDKey;
+    alg: "EdDSA" | "ES256" | "ES384" | "ES512" | "ES256K" | "RS256";
+    document: import("iso-did/types").DIDDocument;
     /**
      * Sign a message
      *
@@ -49,7 +48,8 @@ export class RSASigner implements ISigner {
      * Export the signer as a crypto key pair
      */
     export(): CryptoKeyPair;
+    toString(): string;
+    #private;
 }
 export type ISigner = import('../types.js').ISigner<CryptoKeyPair>;
-import { DIDKey } from 'iso-did/key';
 //# sourceMappingURL=rsa.d.ts.map

package/dist/src/signers/rsa.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rsa.d.ts","sourceRoot":"","sources":["../../../src/signers/rsa.js"],"names":[],"mappings":"AAMA;;GAEG;AAEH;;;;GAIG;AACH;IACE,2EAA2E;IAC3E,YADW,QAAQ,OAAO,eAAe,EAAE,kBAAkB,EAAE,OAAO,CAAC,CACnD;IAEpB,8DAA8D;IAC9D,aADW,QAAQ,OAAO,eAAe,EAAE,OAAO,EAAE,KAAK,CAAC,CACvC;IAGnB,oBAAoB;IAepB;;OAEG;IACH,sCAmBC;IAED;;;;OAIG;IACH,sBAFW,OAAO,aAAa,EAAE,gBAAgB,sBA8BhD;IAED;;;;OAIG;IACH,uBAFW,aAAa,sBASvB;IApFD;;;OAGG;IACH,uBAHW,UAAU,WACV,aAAa,EASvB;IANC,uBAAsB;IACtB,sBAA0B;IAC1B,aAAwB;IACxB,YAA0B;IAC1B,aAA0B;IAC1B,YAA+D;IA4EjE;;;;OAIG;IACH,cAFW,UAAU,uBAUpB;IAED;;OAEG;IACH,wBAEC;CACF;sBA7HY,OAAO,aAAa,EAAE,OAAO,CAAC,aAAa,CAAC;uBAJlC,aAAa"}
+{"version":3,"file":"rsa.d.ts","sourceRoot":"","sources":["../../../src/signers/rsa.js"],"names":[],"mappings":"AAwBA;;;;GAIG;AACH;IACE,2EAA2E;IAC3E,YADW,QAAQ,OAAO,eAAe,EAAE,kBAAkB,EAAE,OAAO,CAAC,CACnD;IAEpB,8DAA8D;IAC9D,aADW,QAAQ,OAAO,eAAe,EAAE,OAAO,EAAE,KAAK,CAAC,CACvC;IAGnB,oBAAoB;IAoBpB;;OAEG;IACH,sCAqBC;IAED;;;;;OAKG;IACH,sBAHW,OAAO,eAAe,EAAE,aAAa,+EAgC/C;IAED;;;;;OAKG;IACH,uBAHW,aAAa,+EAevB;IAhGD;;;OAGG;IACH,iBAHW,OAAO,eAAe,EAAE,aAAa,WACrC,aAAa,EAWvB;IAPC,+BAAkB;IAClB,0CAAkB;IAClB,oEAAoB;IACpB,sBAA8B;IAC9B,gEAAkB;IAClB,8CAA4B;IAuF9B;;;;OAIG;IACH,cAFW,UAAU,uBAUpB;IAED;;OAEG;IACH,wBAEC;IAED,mBAEC;;CACF;sBA7JY,OAAO,aAAa,EAAE,OAAO,CAAC,aAAa,CAAC"}

package/dist/src/types.d.ts

@@ -1,23 +1,9 @@
-import type { DIDKey } from 'iso-did/key';
-import type { SignatureAlgorithm, KeyType } from 'iso-did/types';
-export interface ISigner<Export extends CryptoKeyPair | string> {
-    /**
-     * JWT signing algorithm
-     */
-    alg: SignatureAlgorithm;
-    /**
-     * Keypair type
-     */
-    type: KeyType;
-    /**
-     * Multicodec identifier for the private key
-     */
-    code?: number;
-    did: DIDKey;
-    /**
-     * Sign a message
-     */
+import type { SignatureAlgorithm, VerifiableDID } from 'iso-did/types';
+export interface Sign {
     sign: (message: Uint8Array) => Promise<Uint8Array>;
+}
+export interface ISigner<Export extends CryptoKeyPair | string> extends VerifiableDID, Sign {
+    code?: number;
     export: () => Export;
 }
 export interface VerifyInput {
@@ -38,26 +24,4 @@ export interface IResolver {
 export interface ResolverOptions {
     cache?: Cache | boolean | undefined;
 }
-export interface PublicKeyJwk {
-    kty: string;
-    crv: string;
-    x: string;
-    y: string;
-}
-export interface PublicKeyRSAJwk {
-    kty: string;
-    n: string;
-    e: string;
-}
-export interface PrivateKeyRSAJwk extends PublicKeyRSAJwk {
-    d: string;
-    p: string;
-    q: string;
-    dp: string;
-    dq: string;
-    qi: string;
-}
-export type PrivateKeyJwk = PublicKeyJwk & {
-    d: string;
-};
 //# sourceMappingURL=types.d.ts.map

package/dist/src/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA;AACzC,OAAO,KAAK,EAAE,kBAAkB,EAAE,OAAO,EAAE,MAAM,eAAe,CAAA;AAEhE,MAAM,WAAW,OAAO,CAAC,MAAM,SAAS,aAAa,GAAG,MAAM;IAC5D;;OAEG;IACH,GAAG,EAAE,kBAAkB,CAAA;IACvB;;OAEG;IACH,IAAI,EAAE,OAAO,CAAA;IACb;;OAEG;IACH,IAAI,CAAC,EAAE,MAAM,CAAA;IAEb,GAAG,EAAE,MAAM,CAAA;IACX;;OAEG;IACH,IAAI,EAAE,CAAC,OAAO,EAAE,UAAU,KAAK,OAAO,CAAC,UAAU,CAAC,CAAA;IAElD,MAAM,EAAE,MAAM,MAAM,CAAA;CACrB;AAED,MAAM,WAAW,WAAW;IAC1B,SAAS,EAAE,UAAU,CAAA;IACrB,OAAO,EAAE,UAAU,CAAA;IACnB,SAAS,EAAE,UAAU,CAAA;CACtB;AACD,MAAM,MAAM,MAAM,GAAG,CAAC,KAAK,EAAE,WAAW,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;AAE7D,MAAM,MAAM,QAAQ,CAAC,CAAC,SAAS,kBAAkB,IAAI,MAAM,CAAC,CAAC,EAAE,MAAM,CAAC,CAAA;AAEtE,MAAM,MAAM,gBAAgB,CAAC,CAAC,SAAS,kBAAkB,IAAI,OAAO,CAClE,QAAQ,CAAC,CAAC,CAAC,CACZ,CAAA;AAED,MAAM,WAAW,mBAAoB,SAAQ,WAAW;IACtD,GAAG,EAAE,kBAAkB,CAAA;CACxB;AACD,MAAM,MAAM,KAAK,GAAG,CAAC,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;AAE7E,MAAM,WAAW,SAAS;IACxB,MAAM,EAAE,CAAC,KAAK,EAAE,mBAAmB,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;CACzD;AAED,MAAM,WAAW,eAAe;IAC9B,KAAK,CAAC,EAAE,KAAK,GAAG,OAAO,GAAG,SAAS,CAAA;CACpC;AAED,MAAM,WAAW,YAAY;IAC3B,GAAG,EAAE,MAAM,CAAA;IACX,GAAG,EAAE,MAAM,CAAA;IACX,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;CACV;AAED,MAAM,WAAW,eAAe;IAC9B,GAAG,EAAE,MAAM,CAAA;IACX,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;CACV;AAED,MAAM,WAAW,gBAAiB,SAAQ,eAAe;IACvD,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;IACT,EAAE,EAAE,MAAM,CAAA;IACV,EAAE,EAAE,MAAM,CAAA;IACV,EAAE,EAAE,MAAM,CAAA;CACX;AAED,MAAM,MAAM,aAAa,GAAG,YAAY,GAAG;IAAE,CAAC,EAAE,MAAM,CAAA;CAAE,CAAA"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,aAAa,EAAE,MAAM,eAAe,CAAA;AAEtE,MAAM,WAAW,IAAI;IACnB,IAAI,EAAE,CAAC,OAAO,EAAE,UAAU,KAAK,OAAO,CAAC,UAAU,CAAC,CAAA;CACnD;AAED,MAAM,WAAW,OAAO,CAAC,MAAM,SAAS,aAAa,GAAG,MAAM,CAC5D,SAAQ,aAAa,EACnB,IAAI;IACN,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,MAAM,CAAA;CACrB;AAED,MAAM,WAAW,WAAW;IAC1B,SAAS,EAAE,UAAU,CAAA;IACrB,OAAO,EAAE,UAAU,CAAA;IACnB,SAAS,EAAE,UAAU,CAAA;CACtB;AACD,MAAM,MAAM,MAAM,GAAG,CAAC,KAAK,EAAE,WAAW,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;AAE7D,MAAM,MAAM,QAAQ,CAAC,CAAC,SAAS,kBAAkB,IAAI,MAAM,CAAC,CAAC,EAAE,MAAM,CAAC,CAAA;AAEtE,MAAM,MAAM,gBAAgB,CAAC,CAAC,SAAS,kBAAkB,IAAI,OAAO,CAClE,QAAQ,CAAC,CAAC,CAAC,CACZ,CAAA;AAED,MAAM,WAAW,mBAAoB,SAAQ,WAAW;IACtD,GAAG,EAAE,kBAAkB,CAAA;CACxB;AACD,MAAM,MAAM,KAAK,GAAG,CAAC,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;AAE7E,MAAM,WAAW,SAAS;IACxB,MAAM,EAAE,CAAC,KAAK,EAAE,mBAAmB,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;CACzD;AAED,MAAM,WAAW,eAAe;IAC9B,KAAK,CAAC,EAAE,KAAK,GAAG,OAAO,GAAG,SAAS,CAAA;CACpC"}

package/dist/src/utils.d.ts

@@ -9,4 +9,11 @@ export function createEcdsaParams(alg: import("iso-did/types").SignatureAlgorith
     namedCurve: 'P-256' | 'P-384' | 'P-521';
     hash: 'SHA-256' | 'SHA-384' | 'SHA-512';
 };
+/**
+ *
+ * @param {import('iso-did/types').KeyType} type
+ * @param {BufferSource} publicKey
+ * @param {import('iso-did/types').VerifiableDID} [did]
+ */
+export function didKeyOrVerifiableDID(type: import('iso-did/types').KeyType, publicKey: BufferSource, did?: import("iso-did/types").VerifiableDID | undefined): import("iso-did/types").VerifiableDID;
 //# sourceMappingURL=utils.d.ts.map

package/dist/src/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/utils.js"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,uCAHW,OAAO,eAAe,EAAE,kBAAkB,GACxC;IAAC,MAAM,OAAO,CAAC;IAAC,UAAU,EAAE,OAAO,GAAG,OAAO,GAAG,OAAO,CAAC;IAAC,IAAI,EAAE,SAAS,GAAG,SAAS,GAAG,SAAS,CAAA;CAAC,CA8B7G"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/utils.js"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,uCAHW,OAAO,eAAe,EAAE,kBAAkB,GACxC;IAAC,MAAM,OAAO,CAAC;IAAC,UAAU,EAAE,OAAO,GAAG,OAAO,GAAG,OAAO,CAAC;IAAC,IAAI,EAAE,SAAS,GAAG,SAAS,GAAG,SAAS,CAAA;CAAC,CA8B7G;AAED;;;;;GAKG;AACH,4CAJW,OAAO,eAAe,EAAE,OAAO,aAC/B,YAAY,kGAsBtB"}

package/dist/src/verifiers/ecdsa.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ecdsa.d.ts","sourceRoot":"","sources":["../../../src/verifiers/ecdsa.js"],"names":[],"mappings":"AA+CA;;;;;GAKG;AACH,6BAJW,OAAO,GAAG,OAAO,GAAG,OAAO,qCAC3B,OAAO,aAAa,EAAE,WAAW,oBAK3C;AAfD,0EAA0E;AAC1E,uBADW,OAAO,aAAa,EAAE,QAAQ,CAAC,OAAO,GAAG,OAAO,GAAG,OAAO,CAAC,CAKrE"}
+{"version":3,"file":"ecdsa.d.ts","sourceRoot":"","sources":["../../../src/verifiers/ecdsa.js"],"names":[],"mappings":"AA8CA;;;;;GAKG;AACH,6BAJW,OAAO,GAAG,OAAO,GAAG,OAAO,qCAC3B,OAAO,aAAa,EAAE,WAAW,oBAK3C;AAfD,0EAA0E;AAC1E,uBADW,OAAO,aAAa,EAAE,QAAQ,CAAC,OAAO,GAAG,OAAO,GAAG,OAAO,CAAC,CAKrE"}

package/dist/src/verifiers/eddsa.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"eddsa.d.ts","sourceRoot":"","sources":["../../../src/verifiers/eddsa.js"],"names":[],"mappings":"AAYiQ,gFAAyC;AAJ1S,mDAAmD;AACnD,uBADW,OAAO,UAAU,EAAE,QAAQ,CAAC,OAAO,CAAC,CAG9C"}
+{"version":3,"file":"eddsa.d.ts","sourceRoot":"","sources":["../../../src/verifiers/eddsa.js"],"names":[],"mappings":"AAWsH,gFAAyC;AAJ/J,mDAAmD;AACnD,uBADW,OAAO,UAAU,EAAE,QAAQ,CAAC,OAAO,CAAC,CAG9C"}

package/dist/src/verifiers/resolver.d.ts

@@ -10,9 +10,8 @@ export class Resolver implements IResolver {
      * @param {import('../types').ResolverOptions} options
      */
     constructor(registry?: import('../types').VerifierRegistry<import('iso-did/types').SignatureAlgorithm>, options?: import('../types').ResolverOptions);
-    registry: Partial<import("../types").Verifier<"EdDSA" | "ES256" | "ES384" | "ES512" | "ES256K" | "RS256" | "RS256_OLD">>;
+    registry: Partial<import("../types").Verifier<"EdDSA" | "ES256" | "ES384" | "ES512" | "ES256K" | "RS256">>;
     cache: import("../types").Cache;
-    /** @type {IResolver['verify']} */
     verify(input: import("../types").ResolverVerifyInput): Promise<boolean>;
 }
 export type IResolver = import('../types').IResolver;

package/dist/src/verifiers/resolver.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"resolver.d.ts","sourceRoot":"","sources":["../../../src/verifiers/resolver.js"],"names":[],"mappings":"AAoCA;;;;GAIG;AACH;IACE;;;;OAIG;IACH,uBAHW,OAAO,UAAU,EAAE,gBAAgB,CAAC,OAAO,eAAe,EAAE,kBAAkB,CAAC,YAC/E,OAAO,UAAU,EAAE,eAAe,EAM5C;IAHC,yHAAwB;IACxB,gCACmE;IAGrE,kCAAkC;IAClC,wEAAS;CAQV;wBA7DY,OAAO,UAAU,EAAE,SAAS"}
+{"version":3,"file":"resolver.d.ts","sourceRoot":"","sources":["../../../src/verifiers/resolver.js"],"names":[],"mappings":"AAoCA;;;;GAIG;AACH;IACE;;;;OAIG;IACH,uBAHW,OAAO,UAAU,EAAE,gBAAgB,CAAC,OAAO,eAAe,EAAE,kBAAkB,CAAC,YAC/E,OAAO,UAAU,EAAE,eAAe,EAM5C;IAHC,2GAAwB;IACxB,gCACmE;IALlC,wEAEd;CAetB;wBA7DY,OAAO,UAAU,EAAE,SAAS"}

package/dist/src/verifiers/rsa.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rsa.d.ts","sourceRoot":"","sources":["../../../src/verifiers/rsa.js"],"names":[],"mappings":"AAsBoD,mFAExC;AAFZ,sDAAsD;AACtD,uBADW,OAAO,aAAa,EAAE,QAAQ,CAAC,OAAO,CAAC,CAGjD"}
+{"version":3,"file":"rsa.d.ts","sourceRoot":"","sources":["../../../src/verifiers/rsa.js"],"names":[],"mappings":"AAcQ,mFAAyC;AAOjD,sDAAsD;AACtD,uBADW,OAAO,aAAa,EAAE,QAAQ,CAAC,OAAO,CAAC,CAGjD"}

package/package.json

@@ -1,14 +1,15 @@
 {
   "name": "iso-signatures",
-  "version": "0.1.10",
+  "type": "module",
+  "version": "0.3.0",
   "description": "Signatures tooling.",
   "author": "Hugo Dias <hugomrdias@gmail.com> (hugodias.me)",
   "license": "MIT",
+  "homepage": "https://github.com/hugomrdias/iso-repo/tree/main/packages/iso-signatures",
   "repository": {
     "url": "hugomrdias/iso-repo",
     "directory": "packages/iso-signatures"
   },
-  "homepage": "https://github.com/hugomrdias/iso-repo/tree/main/packages/iso-signatures",
   "keywords": [
     "elliptic",
     "curve",
@@ -25,49 +26,21 @@
     "rsa",
     "signatures"
   ],
-  "type": "module",
-  "main": "src/index.js",
-  "types": "dist/src/index.d.ts",
   "exports": {
     ".": {
       "types": "./dist/src/index.d.ts",
       "import": "./src/index.js"
     },
-    "./signers/ecdsa": {
-      "types": "./dist/src/signers/ecdsa.d.ts",
-      "import": "./src/signers/ecdsa.js"
-    },
-    "./signers/eddsa": {
-      "types": "./dist/src/signers/eddsa.d.ts",
-      "import": "./src/signers/eddsa.js"
-    },
-    "./signers/rsa-old": {
-      "types": "./dist/src/signers/rsa-old.d.ts",
-      "import": "./src/signers/rsa-old.js"
+    "./types": {
+      "types": "./dist/src/types.d.ts"
     },
-    "./signers/rsa": {
-      "types": "./dist/src/signers/rsa.d.ts",
-      "import": "./src/signers/rsa.js"
+    "./signers/*": {
+      "types": "./dist/src/signers/*",
+      "default": "./src/signers/*"
     },
-    "./verifiers/ecdsa": {
-      "types": "./dist/src/verifiers/ecdsa.d.ts",
-      "import": "./src/verifiers/ecdsa.js"
-    },
-    "./verifiers/eddsa": {
-      "types": "./dist/src/verifiers/eddsa.d.ts",
-      "import": "./src/verifiers/eddsa.js"
-    },
-    "./verifiers/rsa-old": {
-      "types": "./dist/src/verifiers/rsa-old.d.ts",
-      "import": "./src/verifiers/rsa-old.js"
-    },
-    "./verifiers/rsa": {
-      "types": "./dist/src/verifiers/rsa.d.ts",
-      "import": "./src/verifiers/rsa.js"
-    },
-    "./verifiers/resolver": {
-      "types": "./dist/src/verifiers/resolver.d.ts",
-      "import": "./src/verifiers/resolver.js"
+    "./verifiers/*": {
+      "types": "./dist/src/verifiers/*",
+      "import": "./src/verifiers/*"
     },
     "./asn1": {
       "types": "./dist/src/asn1.d.ts",
@@ -78,11 +51,16 @@
       "import": "./src/spki.js"
     }
   },
+  "main": "src/index.js",
+  "types": "dist/src/index.d.ts",
   "typesVersions": {
     "*": {
       ".": [
         "dist/src/index"
       ],
+      "types": [
+        "dist/src/types"
+      ],
       "signers/*": [
         "dist/src/signers/*"
       ],
@@ -105,18 +83,17 @@
   "dependencies": {
     "@noble/ed25519": "^2.0.0",
     "iso-base": "^2.0.1",
-    "iso-did": "^1.3.3"
+    "iso-did": "^1.5.0"
   },
   "devDependencies": {
-    "@types/assert": "^1.5.6",
-    "@types/mocha": "^10.0.1",
-    "@types/node": "^20.5.9",
-    "assert": "^2.0.0",
-    "hd-scripts": "^8.0.0",
+    "@types/assert": "^1.5.10",
+    "@types/mocha": "^10.0.6",
+    "@types/node": "^20.10.5",
+    "assert": "^2.1.0",
     "mocha": "^10.2.0",
-    "playwright-test": "^12.2.0",
-    "type-fest": "^4.3.1",
-    "typescript": "5.2.2"
+    "playwright-test": "^14.0.0",
+    "type-fest": "^4.8.3",
+    "typescript": "5.3.3"
   },
   "publishConfig": {
     "provenance": true
@@ -125,9 +102,6 @@
     "extends": [
       "../../node_modules/hd-scripts/eslint/index.js"
     ],
-    "parserOptions": {
-      "project": "./tsconfig.json"
-    },
     "env": {
       "mocha": true
     },
@@ -143,13 +117,14 @@
       "@types/*",
       "hd-scripts",
       "assert",
-      "type-fest"
+      "type-fest",
+      "mocha"
     ]
   },
   "scripts": {
-    "lint": "tsc --build && eslint '**/*.{js,ts}' && prettier --check '**/*.{js,ts,yml,json}' --ignore-path ../../.gitignore",
+    "lint": "tsc --build && eslint . && prettier --check '**/*.{js,ts,yml,json}' --ignore-path ../../.gitignore",
     "test": "tsc --build && pnpm run test:node && pnpm run test:browser",
-    "test:node": "mocha 'test/**/!(*.browser).test.js'",
-    "test:browser": "playwright-test 'test/**/!(*.node).test.js'"
+    "test:node": "pw-test 'test/**/!(*.browser).test.js' --mode node",
+    "test:browser": "pw-test 'test/**/!(*.node).test.js'"
   }
 }

package/readme.md

@@ -13,6 +13,7 @@ pnpm install iso-signatures
 ```js
 import { EdDSASigner } from 'iso-signatures/signers/eddsa'
 import * as EdDSA from 'iso-signatures/verifiers/eddsa'
+import { Resolver } from 'iso-signatures/verifiers/resolver'
 
 const message = new TextEncoder().encode('hello world')
 const resolver = new Resolver({
@@ -32,6 +33,7 @@ import { EdDSASigner } from 'iso-signatures/signers/eddsa'
 import * as EdDSA from 'iso-signatures/verifiers/eddsa'
 import * as ECDSA from 'iso-signatures/verifiers/ecdsa'
 import * as RSA from 'iso-signatures/verifiers/rsa'
+import { Resolver } from 'iso-signatures/verifiers/resolver'
 
 const message = new TextEncoder().encode('hello world')
 const resolver = new Resolver(

package/src/signers/ecdsa.js

@@ -1,8 +1,7 @@
-/* eslint-disable unicorn/numeric-separators-style */
 import { webcrypto } from 'iso-base/crypto'
 import { u8 } from 'iso-base/utils'
-import { DIDKey, keyTypeToAlg } from 'iso-did/key'
-import { createEcdsaParams } from '../utils.js'
+import { DIDKey, algToKeyType, keyTypeToAlg } from 'iso-did/key'
+import { createEcdsaParams, didKeyOrVerifiableDID } from '../utils.js'
 
 /**
  * @typedef {import('../types.js').ISigner<CryptoKeyPair>} ISigner
@@ -13,7 +12,7 @@ import { createEcdsaParams } from '../utils.js'
  * @param {string} alg
  */
 function asECDSAAlg(alg) {
-  if (alg.startsWith('ES')) {
+  if (['ES256', 'ES384', 'ES512'].includes(alg)) {
     return /** @type {ECDSAAlg} */ (alg)
   }
   throw new TypeError(`Unsupported algorithm ${alg}`)
@@ -25,18 +24,24 @@ function asECDSAAlg(alg) {
  * @implements {ISigner}
  */
 export class ECDSASigner {
+  /** @type {ReturnType<createEcdsaParams>} */
+  #params
+
+  /** @type {CryptoKeyPair} */
+  #keypair
   /**
-   * @param {ECDSAAlg} alg
-   * @param {Uint8Array} publicKey
+   * @param {import('iso-did/types').VerifiableDID} did
    * @param {CryptoKeyPair} keypair
    */
-  constructor(alg, publicKey, keypair) {
-    this.params = createEcdsaParams(alg)
-    this.keypair = keypair
-    this.publicKey = publicKey
-    this.alg = alg
-    this.type = this.params.namedCurve
-    this.did = DIDKey.fromPublicKey(this.type, this.publicKey)
+  constructor(did, keypair) {
+    this.did = did.did
+    this.url = did.url
+    this.type = did.type
+    this.publicKey = did.publicKey
+    this.alg = asECDSAAlg(did.alg)
+    this.document = did.document
+    this.#params = createEcdsaParams(this.alg)
+    this.#keypair = keypair
   }
 
   /**
@@ -56,17 +61,22 @@ export class ECDSASigner {
       cryptoKeyPair.publicKey
     )
 
-    return new ECDSASigner(alg, u8(publicKey), cryptoKeyPair)
+    return new ECDSASigner(
+      DIDKey.fromPublicKey(algToKeyType(alg), u8(publicKey)),
+      cryptoKeyPair
+    )
   }
 
   /**
    * Import a signer from a JWK
    *
-   * @param {import('../types.js').PrivateKeyJwk} jwk
+   * @param {import('iso-did/types').ECJWKPrivate} jwk
+   * @param {import('iso-did/types').VerifiableDID} [did]
    */
-  static async importJwk(jwk) {
+  static async importJwk(jwk, did) {
     const alg = asECDSAAlg(keyTypeToAlg(jwk.crv))
     const params = createEcdsaParams(alg)
+    const type = jwk.crv
     const privateKey = await webcrypto.subtle.importKey(
       'jwk',
       jwk,
@@ -84,7 +94,7 @@ export class ECDSASigner {
 
     const publicKey = await webcrypto.subtle.exportKey('raw', publicKeyJWK)
 
-    return new ECDSASigner(alg, u8(publicKey), {
+    return new ECDSASigner(didKeyOrVerifiableDID(type, publicKey, did), {
       privateKey,
       publicKey: publicKeyJWK,
     })
@@ -94,8 +104,9 @@ export class ECDSASigner {
    * Import a signer from a CryptoKeyPair
    *
    * @param {CryptoKeyPair} key
+   * @param {import('iso-did/types').VerifiableDID} [did]
    */
-  static async import(key) {
+  static async import(key, did) {
     const publicKey = await webcrypto.subtle.exportKey('raw', key.publicKey)
 
     /** @type { ECDSAAlg } */
@@ -118,7 +129,11 @@ export class ECDSASigner {
         throw new Error('Unsupported key type')
       }
     }
-    return new ECDSASigner(alg, u8(publicKey), key)
+
+    return new ECDSASigner(
+      didKeyOrVerifiableDID(algToKeyType(alg), publicKey, did),
+      key
+    )
   }
 
   /**
@@ -128,8 +143,8 @@ export class ECDSASigner {
    */
   async sign(message) {
     const buf = await webcrypto.subtle.sign(
-      this.params,
-      this.keypair.privateKey,
+      this.#params,
+      this.#keypair.privateKey,
       message
     )
 
@@ -142,6 +157,10 @@ export class ECDSASigner {
    * @returns {CryptoKeyPair}
    */
   export() {
-    return this.keypair
+    return this.#keypair
+  }
+
+  toString() {
+    return this.url.didUrl
   }
 }

package/src/signers/eddsa.js

@@ -4,6 +4,7 @@ import { webcrypto } from 'iso-base/crypto'
 import { base64pad } from 'iso-base/rfc4648'
 import { tag, untag } from 'iso-base/varint'
 import { DIDKey } from 'iso-did/key'
+import { didKeyOrVerifiableDID } from '../utils.js'
 
 // @ts-ignore
 if (!globalThis.crypto) globalThis.crypto = webcrypto
@@ -12,6 +13,19 @@ if (!globalThis.crypto) globalThis.crypto = webcrypto
  * @typedef {import('../types.js').ISigner<string>} ISigner
  */
 
+/**
+ *
+ * @param {import('iso-did/types').VerifiableDID} did
+ */
+function checkDid(did) {
+  if (did.type !== 'Ed25519') {
+    throw new TypeError(`Unsupported key type ${did.type}`)
+  }
+  if (did.alg !== 'EdDSA') {
+    throw new TypeError(`Unsupported algorithm ${did.alg}`)
+  }
+}
+
 /**
  * EdDSA signer
  *
@@ -26,17 +40,22 @@ export class EdDSASigner {
 
   static code = 0x1300
 
+  /** @type {Uint8Array} */
+  #privateKey
+
   /**
-   * @param {Uint8Array} publicKey
+   * @param {import('iso-did/types').VerifiableDID} did
    * @param {Uint8Array} privateKey
    */
-  constructor(publicKey, privateKey) {
-    this.privateKey = privateKey
-    this.publicKey = publicKey
-    this.alg = EdDSASigner.alg
-    this.type = EdDSASigner.type
-    this.code = EdDSASigner.code
-    this.did = DIDKey.fromPublicKey(EdDSASigner.type, this.publicKey)
+  constructor(did, privateKey) {
+    checkDid(did)
+    this.did = did.did
+    this.url = did.url
+    this.type = did.type
+    this.publicKey = did.publicKey
+    this.alg = did.alg
+    this.document = did.document
+    this.#privateKey = privateKey
   }
 
   /**
@@ -47,19 +66,26 @@ export class EdDSASigner {
   static async generate(bytes) {
     const privateKey = bytes || utils.randomPrivateKey()
     const publicKey = await getPublicKeyAsync(privateKey)
-    return new EdDSASigner(publicKey, privateKey)
+    return new EdDSASigner(
+      DIDKey.fromPublicKey('Ed25519', publicKey),
+      privateKey
+    )
   }
 
   /**
    * Import a signer from a encoded string
    *
    * @param {string} encoded
+   * @param {import('iso-did/types').VerifiableDID} [did]
    */
-  static async import(encoded) {
+  static async import(encoded, did) {
     const privateKey = untag(EdDSASigner.code, base64pad.decode(encoded))
     const publicKey = await getPublicKeyAsync(privateKey)
 
-    return new EdDSASigner(publicKey, privateKey)
+    return new EdDSASigner(
+      didKeyOrVerifiableDID('Ed25519', publicKey, did),
+      privateKey
+    )
   }
 
   /**
@@ -68,13 +94,17 @@ export class EdDSASigner {
    * @param {Uint8Array} message
    */
   async sign(message) {
-    return signAsync(message, this.privateKey)
+    return signAsync(message, this.#privateKey)
   }
 
   /**
    * Export the signer as a encoded string
    */
   export() {
-    return base64pad.encode(tag(EdDSASigner.code, this.privateKey))
+    return base64pad.encode(tag(EdDSASigner.code, this.#privateKey))
+  }
+
+  toString() {
+    return this.url.didUrl
   }
 }

package/src/signers/rsa.js

@@ -3,11 +3,25 @@ import { webcrypto } from 'iso-base/crypto'
 import { u8 } from 'iso-base/utils'
 import { DIDKey } from 'iso-did/key'
 import { spki } from '../spki.js'
+import { didKeyOrVerifiableDID } from '../utils.js'
 
 /**
  * @typedef {import('../types.js').ISigner<CryptoKeyPair>} ISigner
  */
 
+/**
+ *
+ * @param {import('iso-did/types').VerifiableDID} did
+ */
+function checkDid(did) {
+  if (did.type !== RSASigner.type) {
+    throw new TypeError(`Unsupported key type ${did.type}`)
+  }
+  if (did.alg !== RSASigner.alg) {
+    throw new TypeError(`Unsupported algorithm ${did.alg}`)
+  }
+}
+
 /**
  * RSA signer
  *
@@ -23,17 +37,22 @@ export class RSASigner {
   // multicodec code for RSA private key
   static code = 0x1305
 
+  /** @type {CryptoKeyPair} */
+  #keypair
+
   /**
-   * @param {Uint8Array} publicKey
+   * @param {import('iso-did/types').VerifiableDID} did
    * @param {CryptoKeyPair} keypair
    */
-  constructor(publicKey, keypair) {
-    this.keypair = keypair
-    this.publicKey = publicKey
-    this.alg = RSASigner.alg
-    this.type = RSASigner.type
-    this.code = RSASigner.code
-    this.did = DIDKey.fromPublicKey(RSASigner.type, this.publicKey)
+  constructor(did, keypair) {
+    checkDid(did)
+    this.did = did.did
+    this.url = did.url
+    this.type = did.type
+    this.publicKey = did.publicKey
+    this.alg = did.alg
+    this.document = did.document
+    this.#keypair = keypair
   }
 
   /**
@@ -56,16 +75,19 @@ export class RSASigner {
       'spki',
       cryptoKeyPair.publicKey
     )
-
-    return new RSASigner(spki.decode(u8(publicKey)), cryptoKeyPair)
+    return new RSASigner(
+      DIDKey.fromPublicKey('RSA', spki.decode(u8(publicKey))),
+      cryptoKeyPair
+    )
   }
 
   /**
    * Import a signer from a JWK
    *
-   * @param {import('../types.js').PrivateKeyRSAJwk} jwk
+   * @param {import('iso-did/types').RSAJWKPrivate} jwk
+   * @param {import('iso-did/types').VerifiableDID} [did]
    */
-  static async importJwk(jwk) {
+  static async importJwk(jwk, did) {
     const privateKey = await webcrypto.subtle.importKey(
       'jwk',
       jwk,
@@ -88,8 +110,9 @@ export class RSASigner {
     )
 
     const publicKey = await webcrypto.subtle.exportKey('spki', publicKeyJWK)
+    const decodedPublicKey = spki.decode(u8(publicKey))
 
-    return new RSASigner(spki.decode(u8(publicKey)), {
+    return new RSASigner(didKeyOrVerifiableDID('RSA', decodedPublicKey, did), {
       privateKey,
       publicKey: publicKeyJWK,
     })
@@ -99,14 +122,20 @@ export class RSASigner {
    * Import a signer from a keypair
    *
    * @param {CryptoKeyPair} keypair
+   * @param {import('iso-did/types').VerifiableDID} [did]
    */
-  static async import(keypair) {
+  static async import(keypair, did) {
     const publicKey = await webcrypto.subtle.exportKey(
       'spki',
       keypair.publicKey
     )
 
-    return new RSASigner(spki.decode(u8(publicKey)), keypair)
+    const decodedPublicKey = spki.decode(u8(publicKey))
+
+    return new RSASigner(
+      didKeyOrVerifiableDID('RSA', decodedPublicKey, did),
+      keypair
+    )
   }
 
   /**
@@ -117,7 +146,7 @@ export class RSASigner {
   async sign(message) {
     const buf = await webcrypto.subtle.sign(
       { name: 'RSASSA-PKCS1-v1_5', saltLength: 128 },
-      this.keypair.privateKey,
+      this.#keypair.privateKey,
       message
     )
 
@@ -128,6 +157,10 @@ export class RSASigner {
    * Export the signer as a crypto key pair
    */
   export() {
-    return this.keypair
+    return this.#keypair
+  }
+
+  toString() {
+    return this.url.didUrl
   }
 }

package/src/types.ts

@@ -1,26 +1,13 @@
-import type { DIDKey } from 'iso-did/key'
-import type { SignatureAlgorithm, KeyType } from 'iso-did/types'
+import type { SignatureAlgorithm, VerifiableDID } from 'iso-did/types'
 
-export interface ISigner<Export extends CryptoKeyPair | string> {
-  /**
-   * JWT signing algorithm
-   */
-  alg: SignatureAlgorithm
-  /**
-   * Keypair type
-   */
-  type: KeyType
-  /**
-   * Multicodec identifier for the private key
-   */
-  code?: number
-
-  did: DIDKey
-  /**
-   * Sign a message
-   */
+export interface Sign {
   sign: (message: Uint8Array) => Promise<Uint8Array>
+}
 
+export interface ISigner<Export extends CryptoKeyPair | string>
+  extends VerifiableDID,
+    Sign {
+  code?: number
   export: () => Export
 }
 
@@ -49,27 +36,3 @@ export interface IResolver {
 export interface ResolverOptions {
   cache?: Cache | boolean | undefined
 }
-
-export interface PublicKeyJwk {
-  kty: string
-  crv: string
-  x: string
-  y: string
-}
-
-export interface PublicKeyRSAJwk {
-  kty: string
-  n: string
-  e: string
-}
-
-export interface PrivateKeyRSAJwk extends PublicKeyRSAJwk {
-  d: string
-  p: string
-  q: string
-  dp: string
-  dq: string
-  qi: string
-}
-
-export type PrivateKeyJwk = PublicKeyJwk & { d: string }

package/src/utils.js

@@ -1,3 +1,6 @@
+import { DIDKey } from 'iso-did/key'
+import { equals, u8 } from 'iso-base/utils'
+
 /**
  * Create web crypto params for ECDSA.
  *
@@ -33,3 +36,30 @@ export function createEcdsaParams(alg) {
     }
   }
 }
+
+/**
+ *
+ * @param {import('iso-did/types').KeyType} type
+ * @param {BufferSource} publicKey
+ * @param {import('iso-did/types').VerifiableDID} [did]
+ */
+export function didKeyOrVerifiableDID(type, publicKey, did) {
+  /** @type {import('iso-did/types').VerifiableDID} */
+  let _did = DIDKey.fromPublicKey(type, u8(publicKey))
+  if (did) {
+    if (!equals(did.publicKey, _did.publicKey)) {
+      throw new Error('Public key mismatch')
+    }
+
+    if (did.alg !== _did.alg) {
+      throw new Error('Algorithm mismatch')
+    }
+
+    if (did.type !== _did.type) {
+      throw new Error('Key type mismatch')
+    }
+    _did = did
+  }
+
+  return _did
+}

package/src/verifiers/ecdsa.js

@@ -1,4 +1,3 @@
-/* eslint-disable unicorn/numeric-separators-style */
 import { webcrypto } from 'iso-base/crypto'
 import { decompress, isCompressed } from 'iso-base/ec-compression'
 import { createEcdsaParams } from '../utils.js'

package/src/verifiers/eddsa.js

@@ -1,4 +1,3 @@
-/* eslint-disable unicorn/numeric-separators-style */
 import { verifyAsync } from '@noble/ed25519'
 
 /** @type {import('../types').Verify} */

package/src/verifiers/rsa.js

@@ -1,4 +1,3 @@
-/* eslint-disable unicorn/numeric-separators-style */
 import { webcrypto } from 'iso-base/crypto'
 import { spki } from '../spki.js'
 

package/dist/src/signers/rsa-old.d.ts

@@ -1,53 +0,0 @@
-/**
- * @typedef {import('../types.js').ISigner<CryptoKeyPair>} ISigner
- */
-/**
- * RSA Old fission format signer
- *
- * @implements {ISigner}
- */
-export class RSAOldSigner implements ISigner {
-    /** @type {Extract<import('iso-did/types').SignatureAlgorithm, "RS256_OLD">} */
-    static alg: Extract<import('iso-did/types').SignatureAlgorithm, "RS256_OLD">;
-    /** @type {Extract<import('iso-did/types').KeyType, "RSA_OLD">} */
-    static type: Extract<import('iso-did/types').KeyType, "RSA_OLD">;
-    /**
-     * Generate a new signer
-     */
-    static generate(): Promise<RSAOldSigner>;
-    /**
-     * Import a signer from a JWK
-     *
-     * @param {import('../types.js').PrivateKeyRSAJwk} jwk
-     */
-    static importJwk(jwk: import('../types.js').PrivateKeyRSAJwk): Promise<RSAOldSigner>;
-    /**
-     * Import a signer from a keypair
-     *
-     * @param {CryptoKeyPair} keypair
-     */
-    static import(keypair: CryptoKeyPair): Promise<RSAOldSigner>;
-    /**
-     * @param {Uint8Array} publicKey
-     * @param {CryptoKeyPair} keypair
-     */
-    constructor(publicKey: Uint8Array, keypair: CryptoKeyPair);
-    keypair: CryptoKeyPair;
-    publicKey: Uint8Array;
-    alg: "RS256_OLD";
-    type: "RSA_OLD";
-    did: DIDKey;
-    /**
-     * Sign a message
-     *
-     * @param {Uint8Array} message
-     */
-    sign(message: Uint8Array): Promise<Uint8Array>;
-    /**
-     * Export the signer as a crypto key pair
-     */
-    export(): CryptoKeyPair;
-}
-export type ISigner = import('../types.js').ISigner<CryptoKeyPair>;
-import { DIDKey } from 'iso-did/key';
-//# sourceMappingURL=rsa-old.d.ts.map

package/dist/src/signers/rsa-old.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"rsa-old.d.ts","sourceRoot":"","sources":["../../../src/signers/rsa-old.js"],"names":[],"mappings":"AAKA;;GAEG;AAEH;;;;GAIG;AACH;IACE,+EAA+E;IAC/E,YADW,QAAQ,OAAO,eAAe,EAAE,kBAAkB,EAAE,WAAW,CAAC,CACnD;IAExB,kEAAkE;IAClE,aADW,QAAQ,OAAO,eAAe,EAAE,OAAO,EAAE,SAAS,CAAC,CACvC;IAcvB;;OAEG;IACH,yCAmBC;IAED;;;;OAIG;IACH,sBAFW,OAAO,aAAa,EAAE,gBAAgB,yBA8BhD;IAED;;;;OAIG;IACH,uBAFW,aAAa,yBASvB;IAnFD;;;OAGG;IACH,uBAHW,UAAU,WACV,aAAa,EAQvB;IALC,uBAAsB;IACtB,sBAA0B;IAC1B,iBAA2B;IAC3B,gBAA6B;IAC7B,YAAkE;IA4EpE;;;;OAIG;IACH,cAFW,UAAU,uBAUpB;IAED;;OAEG;IACH,wBAEC;CACF;sBAzHY,OAAO,aAAa,EAAE,OAAO,CAAC,aAAa,CAAC;uBAHlC,aAAa"}

package/dist/src/verifiers/rsa-old.d.ts

@@ -1,4 +0,0 @@
-export function verify(input: import("../types.js").VerifyInput): Promise<boolean>;
-/** @type {import('../types.js').Verifier<'RS256_OLD'>} */
-export const verifier: import('../types.js').Verifier<'RS256_OLD'>;
-//# sourceMappingURL=rsa-old.d.ts.map

package/dist/src/verifiers/rsa-old.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"rsa-old.d.ts","sourceRoot":"","sources":["../../../src/verifiers/rsa-old.js"],"names":[],"mappings":"AAuBc,mFAEkB;AAJhC,0DAA0D;AAC1D,uBADW,OAAO,aAAa,EAAE,QAAQ,CAAC,WAAW,CAAC,CAGrD"}

package/src/signers/rsa-old.js

@@ -1,128 +0,0 @@
-/* eslint-disable unicorn/numeric-separators-style */
-import { webcrypto } from 'iso-base/crypto'
-import { u8 } from 'iso-base/utils'
-import { DIDKey } from 'iso-did/key'
-
-/**
- * @typedef {import('../types.js').ISigner<CryptoKeyPair>} ISigner
- */
-
-/**
- * RSA Old fission format signer
- *
- * @implements {ISigner}
- */
-export class RSAOldSigner {
-  /** @type {Extract<import('iso-did/types').SignatureAlgorithm, "RS256_OLD">} */
-  static alg = 'RS256_OLD'
-
-  /** @type {Extract<import('iso-did/types').KeyType, "RSA_OLD">} */
-  static type = 'RSA_OLD'
-
-  /**
-   * @param {Uint8Array} publicKey
-   * @param {CryptoKeyPair} keypair
-   */
-  constructor(publicKey, keypair) {
-    this.keypair = keypair
-    this.publicKey = publicKey
-    this.alg = RSAOldSigner.alg
-    this.type = RSAOldSigner.type
-    this.did = DIDKey.fromPublicKey(RSAOldSigner.type, this.publicKey)
-  }
-
-  /**
-   * Generate a new signer
-   */
-  static async generate() {
-    const cryptoKeyPair = await webcrypto.subtle.generateKey(
-      {
-        name: 'RSASSA-PKCS1-v1_5',
-        modulusLength: 2048,
-        publicExponent: new Uint8Array([0x01, 0x00, 0x01]),
-        hash: { name: 'SHA-256' },
-      },
-
-      false,
-      ['sign', 'verify']
-    )
-
-    const publicKey = await webcrypto.subtle.exportKey(
-      'spki',
-      cryptoKeyPair.publicKey
-    )
-
-    return new RSAOldSigner(u8(publicKey), cryptoKeyPair)
-  }
-
-  /**
-   * Import a signer from a JWK
-   *
-   * @param {import('../types.js').PrivateKeyRSAJwk} jwk
-   */
-  static async importJwk(jwk) {
-    const privateKey = await webcrypto.subtle.importKey(
-      'jwk',
-      jwk,
-      {
-        name: 'RSASSA-PKCS1-v1_5',
-        hash: 'SHA-256',
-      },
-      false,
-      ['sign']
-    )
-    const publicKeyJWK = await webcrypto.subtle.importKey(
-      'jwk',
-      { ...jwk, d: undefined },
-      {
-        name: 'RSASSA-PKCS1-v1_5',
-        hash: 'SHA-256',
-      },
-      true,
-      ['verify']
-    )
-
-    const publicKey = await webcrypto.subtle.exportKey('spki', publicKeyJWK)
-
-    return new RSAOldSigner(u8(publicKey), {
-      privateKey,
-      publicKey: publicKeyJWK,
-    })
-  }
-
-  /**
-   * Import a signer from a keypair
-   *
-   * @param {CryptoKeyPair} keypair
-   */
-  static async import(keypair) {
-    const publicKey = await webcrypto.subtle.exportKey(
-      'spki',
-      keypair.publicKey
-    )
-
-    return new RSAOldSigner(u8(publicKey), keypair)
-  }
-
-  /**
-   * Sign a message
-   *
-   * @param {Uint8Array} message
-   */
-  async sign(message) {
-    const buf = await webcrypto.subtle.sign(
-      { name: 'RSASSA-PKCS1-v1_5', saltLength: 128 },
-      this.keypair.privateKey,
-      message
-    )
-
-    return u8(buf)
-  }
-
-  /**
-   * Export the signer as a crypto key pair
-   */
-  export() {
-    return this.keypair
-  }
-}

package/src/verifiers/rsa-old.js

@@ -1,25 +0,0 @@
-/* eslint-disable unicorn/numeric-separators-style */
-import { webcrypto } from 'iso-base/crypto'
-
-/** @type {import('../types.js').Verify} */
-export async function verify({ signature, message, publicKey }) {
-  const key = await webcrypto.subtle.importKey(
-    'spki',
-    publicKey,
-    { name: 'RSASSA-PKCS1-v1_5', hash: { name: 'SHA-256' } },
-    true,
-    ['verify']
-  )
-
-  return await webcrypto.subtle.verify(
-    { name: 'RSASSA-PKCS1-v1_5', saltLength: 128 },
-    key,
-    signature,
-    message
-  )
-}
-
-/** @type {import('../types.js').Verifier<'RS256_OLD'>} */
-export const verifier = {
-  RS256_OLD: verify,
-}