iso-signatures 0.2.0 → 0.3.0

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":"AAoBA;;;;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 { KeyType, SignatureAlgorithm } 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,OAAO,EAAE,kBAAkB,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/eddsa.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"eddsa.d.ts","sourceRoot":"","sources":["../../../src/verifiers/eddsa.js"],"names":[],"mappings":"AAWuT,gFAAyC;AAJhW,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

@@ -12,7 +12,6 @@ export class Resolver implements IResolver {
     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">>;
     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,2GAAwB;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":"AAyBM,mFAAyC;AAJ/C,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,7 +1,7 @@
 {
   "name": "iso-signatures",
   "type": "module",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Signatures tooling.",
   "author": "Hugo Dias <hugomrdias@gmail.com> (hugodias.me)",
   "license": "MIT",
@@ -83,12 +83,12 @@
   "dependencies": {
     "@noble/ed25519": "^2.0.0",
     "iso-base": "^2.0.1",
-    "iso-did": "^1.4.0"
+    "iso-did": "^1.5.0"
   },
   "devDependencies": {
     "@types/assert": "^1.5.10",
     "@types/mocha": "^10.0.6",
-    "@types/node": "^20.10.4",
+    "@types/node": "^20.10.5",
     "assert": "^2.1.0",
     "mocha": "^10.2.0",
     "playwright-test": "^14.0.0",

package/src/signers/ecdsa.js

@@ -1,7 +1,7 @@
 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
@@ -12,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}`)
@@ -24,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
   }
 
   /**
@@ -55,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,
@@ -83,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,
     })
@@ -93,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 } */
@@ -117,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
+    )
   }
 
   /**
@@ -127,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
     )
 
@@ -141,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 { KeyType, SignatureAlgorithm } 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
+}