iso-signatures 0.5.0 → 0.5.1

package/dist/src/asn1.d.ts

@@ -6,26 +6,26 @@ export const OBJECT_TAG: 6;
 export const SEQUENCE_TAG: 48;
 export const UNUSED_BIT_PAD: 0;
 export function encodeDERLength(length: number): Uint8Array<ArrayBuffer>;
-export function readDERLength(bytes: Uint8Array<ArrayBuffer>, offset?: number): {
+export function readDERLength(bytes: Uint8Array, offset?: number): {
     number: number;
     consumed: number;
 };
-export function skip(input: Uint8Array<ArrayBuffer>, expectedTag: number, position: number): number;
-export function into(input: Uint8Array<ArrayBuffer>, expectedTag: number, offset: number): {
+export function skip(input: Uint8Array, expectedTag: number, position: number): number;
+export function into(input: Uint8Array, expectedTag: number, offset: number): {
     position: number;
     length: number;
 };
-export function encodeBitString(input: Uint8Array<ArrayBuffer>): Uint8Array<ArrayBuffer>;
-export function encodeOctetString(input: Uint8Array<ArrayBuffer>): Uint8Array<ArrayBuffer>;
-export function encodeSequence(sequence: Uint8Array<ArrayBuffer>[]): Uint8Array<ArrayBuffer>;
-export function readSequence(bytes: Uint8Array<ArrayBuffer>, offset?: number): Uint8Array<ArrayBuffer>;
-export function encodeInt(input: Uint8Array<ArrayBuffer>): Uint8Array<ArrayBuffer>;
-export function enterSequence(bytes: Uint8Array<ArrayBuffer>, offset?: number): number;
-export function skipSequence(bytes: Uint8Array<ArrayBuffer>, offset?: number): number;
-export function skipInt(bytes: Uint8Array<ArrayBuffer>, offset?: number): number;
-export function readBitString(bytes: Uint8Array<ArrayBuffer>, offset?: number): Uint8Array<ArrayBuffer>;
-export function readInt(bytes: Uint8Array<ArrayBuffer>, byteOffset?: number): Uint8Array<ArrayBuffer>;
-export function readOctetString(bytes: Uint8Array<ArrayBuffer>, offset?: number): Uint8Array<ArrayBuffer>;
-export function readSequenceWith(readers: [Reader, ...Reader[]], source: Uint8Array<ArrayBuffer>, byteOffset?: number): Uint8Array<ArrayBuffer>[];
-export type Reader = (bytes: Uint8Array<ArrayBuffer>, offset: number) => Uint8Array<ArrayBuffer>;
+export function encodeBitString(input: Uint8Array): Uint8Array<ArrayBuffer>;
+export function encodeOctetString(input: Uint8Array): Uint8Array<ArrayBuffer>;
+export function encodeSequence(sequence: Uint8Array[]): Uint8Array<ArrayBuffer>;
+export function readSequence(bytes: Uint8Array, offset?: number): Uint8Array<ArrayBufferLike>;
+export function encodeInt(input: Uint8Array): Uint8Array<ArrayBuffer>;
+export function enterSequence(bytes: Uint8Array, offset?: number): number;
+export function skipSequence(bytes: Uint8Array, offset?: number): number;
+export function skipInt(bytes: Uint8Array, offset?: number): number;
+export function readBitString(bytes: Uint8Array, offset?: number): Uint8Array<ArrayBufferLike>;
+export function readInt(bytes: Uint8Array, byteOffset?: number): Uint8Array<ArrayBufferLike>;
+export function readOctetString(bytes: Uint8Array, offset?: number): Uint8Array<ArrayBufferLike>;
+export function readSequenceWith(readers: [Reader, ...Reader[]], source: Uint8Array, byteOffset?: number): Uint8Array<ArrayBufferLike>[];
+export type Reader = (bytes: Uint8Array, offset: number) => Uint8Array;
 //# sourceMappingURL=asn1.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"asn1.d.ts","sourceRoot":"","sources":["../../src/asn1.js"],"names":[],"mappings":"AAIA,sBAAuB,CAAI,CAAA;AAC3B,4BAA6B,CAAI,CAAA;AACjC,+BAAgC,CAAI,CAAA;AACpC,uBAAwB,CAAI,CAAA;AAC5B,yBAA0B,CAAI,CAAA;AAC9B,2BAA4B,EAAI,CAAA;AAEhC,6BAA8B,CAAI,CAAA;AAK3B,wCAFI,MAAM,2BAehB;AAMM,qCAHI,UAAU,CAAC,WAAW,CAAC,WACvB,MAAM;;;EAsBhB;AAOM,4BAJI,UAAU,CAAC,WAAW,CAAC,eACvB,MAAM,YACN,MAAM,UAKhB;AAOM,4BAJI,UAAU,CAAC,WAAW,CAAC,eACvB,MAAM,UACN,MAAM;;;EAmBhB;AAKM,uCAFI,UAAU,CAAC,WAAW,CAAC,2BA8BjC;AAKM,yCAFI,UAAU,CAAC,WAAW,CAAC,2BAqBjC;AAKM,yCAFI,UAAU,CAAC,WAAW,CAAC,EAAE,2BAgCnC;AAMM,oCAHI,UAAU,CAAC,WAAW,CAAC,WACvB,MAAM,2BAMhB;AAKM,iCAFI,UAAU,CAAC,WAAW,CAAC,2BAkCjC;AAOM,qCAJI,UAAU,CAAC,WAAW,CAAC,WACvB,MAAM,UAI2B;AAMrC,oCAHI,UAAU,CAAC,WAAW,CAAC,WACvB,MAAM,UAGkB;AAM5B,+BAHI,UAAU,CAAC,WAAW,CAAC,WACvB,MAAM,UAEyD;AAKnE,qCAFI,UAAU,CAAC,WAAW,CAAC,4CAiBjC;AAMM,+BAHI,UAAU,CAAC,WAAW,CAAC,eACvB,MAAM,2BAgBhB;AAMM,uCAHI,UAAU,CAAC,WAAW,CAAC,WACvB,MAAM,2BAMhB;AAQM,0CAJI,CAAC,MAAM,EAAE,GAAG,MAAM,EAAE,CAAC,UACrB,UAAU,CAAC,WAAW,CAAC,eACvB,MAAM,6BAYhB;qBAfY,CAAC,KAAK,EAAC,UAAU,CAAC,WAAW,CAAC,EAAE,MAAM,EAAC,MAAM,KAAK,UAAU,CAAC,WAAW,CAAC"}
+{"version":3,"file":"asn1.d.ts","sourceRoot":"","sources":["../../src/asn1.js"],"names":[],"mappings":"AAIA,sBAAuB,CAAI,CAAA;AAC3B,4BAA6B,CAAI,CAAA;AACjC,+BAAgC,CAAI,CAAA;AACpC,uBAAwB,CAAI,CAAA;AAC5B,yBAA0B,CAAI,CAAA;AAC9B,2BAA4B,EAAI,CAAA;AAEhC,6BAA8B,CAAI,CAAA;AAK3B,wCAFI,MAAM,2BAehB;AAMM,qCAHI,UAAU,WACV,MAAM;;;EAsBhB;AAOM,4BAJI,UAAU,eACV,MAAM,YACN,MAAM,UAKhB;AAOM,4BAJI,UAAU,eACV,MAAM,UACN,MAAM;;;EAmBhB;AAKM,uCAFI,UAAU,2BA8BpB;AAKM,yCAFI,UAAU,2BAqBpB;AAKM,yCAFI,UAAU,EAAE,2BAgCtB;AAMM,oCAHI,UAAU,WACV,MAAM,+BAMhB;AAKM,iCAFI,UAAU,2BAkCpB;AAOM,qCAJI,UAAU,WACV,MAAM,UAI2B;AAMrC,oCAHI,UAAU,WACV,MAAM,UAGkB;AAM5B,+BAHI,UAAU,WACV,MAAM,UAEyD;AAKnE,qCAFI,UAAU,gDAiBpB;AAMM,+BAHI,UAAU,eACV,MAAM,+BAgBhB;AAMM,uCAHI,UAAU,WACV,MAAM,+BAMhB;AAQM,0CAJI,CAAC,MAAM,EAAE,GAAG,MAAM,EAAE,CAAC,UACrB,UAAU,eACV,MAAM,iCAYhB;qBAfY,CAAC,KAAK,EAAC,UAAU,EAAE,MAAM,EAAC,MAAM,KAAK,UAAU"}

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

@@ -46,9 +46,9 @@ export class ECDSASigner extends DID implements ISigner {
     /**
      * Sign a message
      *
-     * @param {Uint8Array<ArrayBuffer>} message
+     * @param {Uint8Array} message
      */
-    sign(message: Uint8Array<ArrayBuffer>): Promise<Uint8Array<ArrayBuffer>>;
+    sign(message: Uint8Array): Promise<Uint8Array<ArrayBufferLike>>;
     /**
      * Export the signer as a CryptoKeyPair
      *

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

@@ -1 +1 @@
-{"version":3,"file":"ecdsa.d.ts","sourceRoot":"","sources":["../../../src/signers/ecdsa.js"],"names":[],"mappings":"AAwCA;;;;;GAKG;AACH,yCAHW,MAAM,GACJ;IAAC,IAAI,EAAE,OAAO,CAAC;IAAC,UAAU,EAAE,OAAO,GAAG,OAAO,GAAG,OAAO,CAAC;IAAC,IAAI,EAAE,SAAS,GAAG,SAAS,GAAG,SAAS,CAAA;CAAC,CA8B7G;AAED;;;;GAIG;AACH,gDAFgB,OAAO;IAuBrB;;;;OAIG;IACH,uBAFW,MAAM,wBAkBhB;IAED;;;;;OAKG;IACH,sBAHW,OAAO,eAAe,EAAE,YAAY,QACpC,OAAO,eAAe,EAAE,aAAa,wBA2B/C;IAED;;;;;OAKG;IACH,mBAHW,aAAa,QACb,OAAO,eAAe,EAAE,aAAa,wBA2B/C;IAnGD;;;OAGG;IACH,iBAHW,OAAO,eAAe,EAAE,aAAa,WACrC,aAAa,EAQvB;IAZD,kDAAkD;IAClD,eADW,OAAO,aAAa,EAAE,aAAa,CACjC;IAOX,mCAA+C;IA+FjD;;;;OAIG;IACH,cAFW,UAAU,CAAC,WAAW,CAAC,oCAUjC;IAED;;;;OAIG;IACH,UAFa,aAAa,CAIzB;;CAKF;sBAnNY,OAAO,aAAa,EAAE,OAAO,CAAC,aAAa,CAAC;qBAC5C,OAAO,CAAC,OAAO,eAAe,EAAE,OAAO,EAAE,OAAO,GAAG,OAAO,GAAG,OAAO,CAAC;6BACrE,OAAO,CAAC,OAAO,aAAa,EAAE,aAAa,EAAE,OAAO,GAAG,OAAO,GAAG,OAAO,CAAC;oBAPlE,SAAS"}
+{"version":3,"file":"ecdsa.d.ts","sourceRoot":"","sources":["../../../src/signers/ecdsa.js"],"names":[],"mappings":"AAwCA;;;;;GAKG;AACH,yCAHW,MAAM,GACJ;IAAC,IAAI,EAAE,OAAO,CAAC;IAAC,UAAU,EAAE,OAAO,GAAG,OAAO,GAAG,OAAO,CAAC;IAAC,IAAI,EAAE,SAAS,GAAG,SAAS,GAAG,SAAS,CAAA;CAAC,CA8B7G;AAED;;;;GAIG;AACH,gDAFgB,OAAO;IAuBrB;;;;OAIG;IACH,uBAFW,MAAM,wBAkBhB;IAED;;;;;OAKG;IACH,sBAHW,OAAO,eAAe,EAAE,YAAY,QACpC,OAAO,eAAe,EAAE,aAAa,wBA2B/C;IAED;;;;;OAKG;IACH,mBAHW,aAAa,QACb,OAAO,eAAe,EAAE,aAAa,wBA8B/C;IAtGD;;;OAGG;IACH,iBAHW,OAAO,eAAe,EAAE,aAAa,WACrC,aAAa,EAQvB;IAZD,kDAAkD;IAClD,eADW,OAAO,aAAa,EAAE,aAAa,CACjC;IAOX,mCAA+C;IAkGjD;;;;OAIG;IACH,cAFW,UAAU,wCAUpB;IAED;;;;OAIG;IACH,UAFa,aAAa,CAIzB;;CAKF;sBAtNY,OAAO,aAAa,EAAE,OAAO,CAAC,aAAa,CAAC;qBAC5C,OAAO,CAAC,OAAO,eAAe,EAAE,OAAO,EAAE,OAAO,GAAG,OAAO,GAAG,OAAO,CAAC;6BACrE,OAAO,CAAC,OAAO,aAAa,EAAE,aAAa,EAAE,OAAO,GAAG,OAAO,GAAG,OAAO,CAAC;oBAPlE,SAAS"}

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

@@ -40,9 +40,9 @@ export class EdDSASigner extends DID implements ISigner {
     /**
      * Sign a message
      *
-     * @param {Uint8Array<ArrayBuffer>} message
+     * @param {Uint8Array} message
      */
-    sign(message: Uint8Array<ArrayBuffer>): Promise<Uint8Array<ArrayBuffer>>;
+    sign(message: Uint8Array): Promise<import("@noble/ed25519").Bytes>;
     /**
      * Export the signer as a encoded string
      */

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

@@ -1 +1 @@
-{"version":3,"file":"eddsa.d.ts","sourceRoot":"","sources":["../../../src/signers/eddsa.js"],"names":[],"mappings":"AAyBA;;;;GAIG;AACH,gDAFgB,OAAO;IAGrB;;;;OAIG;IACH,aAFU,MAAM,CAEI;IAmBpB;;;;OAIG;IACH,wBAFW,UAAU,wBAoBpB;IAED;;;;;OAKG;IACH,uBAHW,MAAM,QACN,OAAO,eAAe,EAAE,aAAa,wBAc/C;IAED;;;;;OAKG;IACH,sBAHW,OAAO,eAAe,EAAE,aAAa,QACrC,OAAO,eAAe,EAAE,aAAa,eAU/C;IAtED;;;OAGG;IACH,iBAHW,OAAO,eAAe,EAAE,aAAa,cACrC,UAAU,EAOpB;IAZD,kDAAkD;IAClD,eADW,OAAO,aAAa,EAAE,aAAa,CACjC;IA0Eb;;;;OAIG;IACH,cAFW,UAAU,CAAC,WAAW,CAAC,GAGd,OAAO,CAAC,UAAU,CAAC,WAAW,CAAC,CAAC,CAGnD;IAED;;OAEG;IACH,iBAEC;;CAKF;sBA7HY,OAAO,aAAa,EAAE,OAAO,CAAC,MAAM,CAAC;oBAP9B,SAAS"}
+{"version":3,"file":"eddsa.d.ts","sourceRoot":"","sources":["../../../src/signers/eddsa.js"],"names":[],"mappings":"AAyBA;;;;GAIG;AACH,gDAFgB,OAAO;IAGrB;;;;OAIG;IACH,aAFU,MAAM,CAEI;IAmBpB;;;;OAIG;IACH,wBAFW,UAAU,wBAiBpB;IAED;;;;;OAKG;IACH,uBAHW,MAAM,QACN,OAAO,eAAe,EAAE,aAAa,wBAU/C;IAED;;;;;OAKG;IACH,sBAHW,OAAO,eAAe,EAAE,aAAa,QACrC,OAAO,eAAe,EAAE,aAAa,eAU/C;IA/DD;;;OAGG;IACH,iBAHW,OAAO,eAAe,EAAE,aAAa,cACrC,UAAU,EAOpB;IAZD,kDAAkD;IAClD,eADW,OAAO,aAAa,EAAE,aAAa,CACjC;IAmEb;;;;OAIG;IACH,cAFW,UAAU,2CAIpB;IAED;;OAEG;IACH,iBAEC;;CAKF;sBApHY,OAAO,aAAa,EAAE,OAAO,CAAC,MAAM,CAAC;oBAP9B,SAAS"}

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

@@ -534,9 +534,9 @@ export class EIP191Signer extends DID implements ISigner {
     /**
      * Sign a message
      *
-     * @param {Uint8Array<ArrayBuffer>} message
+     * @param {Uint8Array} message
      */
-    sign(message: Uint8Array<ArrayBuffer>): Promise<Uint8Array<ArrayBuffer>>;
+    sign(message: Uint8Array): Promise<Uint8Array<ArrayBufferLike>>;
     /**
      * Export the signer as a encoded string
      */

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

@@ -1 +1 @@
-{"version":3,"file":"eip191.d.ts","sourceRoot":"","sources":["../../../src/signers/eip191.js"],"names":[],"mappings":"AAKA;;;GAGG;AAEH;;;;GAIG;AACH,iDAFgB,OAAO;IAuBrB;;;;;;;;;;;;;;;;;OAiBG;IACH,qBAdG;QAA0B,QAAQ,EAA1B,QAAQ;QACgB,OAAO;QACE,OAAO;QACvB,SAAS;KAElC,yBAwBF;IAlDD;;;;;;;OAOG;IACH,sBALW,QAAQ,WACR,KAAK,MAAM,EAAE,YACb,MAAM,GAAG,KAAK,MAAM,EAAE,cACtB,MAAM,EAShB;IAlBD,kDAAkD;IAClD,eADW,OAAO,aAAa,EAAE,aAAa,CACjC;IAaX;;;;sBAW4D,CAAC;;;;;;sBAQzD,CAAC;;;;;;sBAS2B,CAAC;;;;;;;;;;;;sBAqC2P,CAAC;;;;;;sBAAmP,CAAC;;;;;;;;;;;;;;;;;;sBAA6jE,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAAqxP,CAAC;;;;;;sBAAkT,CAAC;;;;;;;;;;;;sBAAovB,CAAC;;;;;;sBAAuQ,CAAC;;;;;;sBAAwW,CAAC;;;;;;;;;;;;;;;;;;;;sCAA+4B,CAAC;6BAA2D,CAAC;sCAAmF,CAAC;;0CAA6F,CAAC;kCAAqD,CAAC;8BAAiD,CAAC;;;;qBAAkM,CAAC;yBAA8B,CAAC;4BAAwB,CAAC;;;;wBAAiI,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;sBApE3ib,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAoEkgC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAA0Q,CAAC;;;;;;;;;;sBAA+Z,CAAC;;;;;;;;;;;;;;;sBAAmQ,CAAC;;;4BAAguI,CAAC;;;;;;;;gCAA4M,CAAC;;;;;;;;;;;;;;;;4BAA2f,CAAC;;;;;iCAA8H,CAAC;mCAAoD,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCAA+R,CAAC;;;0BAAgD,CAAC;4BAA+C,CAAC;6BAAwC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BAA68B,CAAC;;;;;;;;MAjEt6Q;IACxB,uBAAsB;IACtB,gCAAsB;IACtB,kBAA0B;IAsC5B;;;;OAIG;IACH,cAFW,UAAU,CAAC,WAAW,CAAC,oCAQjC;IAED;;OAEG;IACH,iBAEC;CAKF;sBAxFY,OAAO,aAAa,EAAE,OAAO,CAAC,MAAM,CAAC;uBACrC,OAAO,IAAI,EAAE,QAAQ,CAAC,QAAQ;oBANvB,SAAS;yBAEJ,IAAI"}
+{"version":3,"file":"eip191.d.ts","sourceRoot":"","sources":["../../../src/signers/eip191.js"],"names":[],"mappings":"AAKA;;;GAGG;AAEH;;;;GAIG;AACH,iDAFgB,OAAO;IAuBrB;;;;;;;;;;;;;;;;;OAiBG;IACH,qBAdG;QAA0B,QAAQ,EAA1B,QAAQ;QACgB,OAAO;QACE,OAAO;QACvB,SAAS;KAElC,yBAwBF;IAlDD;;;;;;;OAOG;IACH,sBALW,QAAQ,WACR,KAAK,MAAM,EAAE,YACb,MAAM,GAAG,KAAK,MAAM,EAAE,cACtB,MAAM,EAShB;IAlBD,kDAAkD;IAClD,eADW,OAAO,aAAa,EAAE,aAAa,CACjC;IAaX;;;;sBAW4D,CAAC;;;;;;sBAQzD,CAAC;;;;;;sBAS2B,CAAC;;;;;;;;;;;;sBAqCwQ,CAAC;;;;;;sBAAmP,CAAC;;;;;;;;;;;;;;;;;;sBAA6jE,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAAqxP,CAAC;;;;;;sBAAkT,CAAC;;;;;;;;;;;;sBAAovB,CAAC;;;;;;sBAAuQ,CAAC;;;;;;sBAAwW,CAAC;;;;;;;;;;;;;;;;;;;;sCAA+4B,CAAC;6BAA2D,CAAC;sCAAmF,CAAC;;0CAA6F,CAAC;kCAAqD,CAAC;8BAAiD,CAAC;;;;qBAAkM,CAAC;yBAA8B,CAAC;4BAAwB,CAAC;;;;wBAAiI,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;sBApExjb,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAoE+gC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAA0Q,CAAC;;;;;;;;;;sBAA+Z,CAAC;;;;;;;;;;;;;;;sBAAmQ,CAAC;;;4BAAguI,CAAC;;;;;;;;gCAA4M,CAAC;;;;;;;;;;;;;;;;4BAA2f,CAAC;;;;;iCAA8H,CAAC;mCAAoD,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCAA+R,CAAC;;;0BAAgD,CAAC;4BAA+C,CAAC;6BAAwC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BAA68B,CAAC;;;;;;;;MAjEn7Q;IACxB,uBAAsB;IACtB,gCAAsB;IACtB,kBAA0B;IAsC5B;;;;OAIG;IACH,cAFW,UAAU,wCAQpB;IAED;;OAEG;IACH,iBAEC;CAKF;sBAxFY,OAAO,aAAa,EAAE,OAAO,CAAC,MAAM,CAAC;uBACrC,OAAO,IAAI,EAAE,QAAQ,CAAC,QAAQ;oBANvB,SAAS;yBAEJ,IAAI"}

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

@@ -13,9 +13,9 @@ export class ES256KSigner extends DID implements ISigner {
     /**
      * Generate a new signer
      *
-     * @param {Uint8Array<ArrayBuffer>} [bytes]
+     * @param {Uint8Array} [bytes]
      */
-    static generate(bytes?: Uint8Array<ArrayBuffer>): ES256KSigner;
+    static generate(bytes?: Uint8Array): ES256KSigner;
     /**
      * Import a signer from a JWK
      *
@@ -41,9 +41,9 @@ export class ES256KSigner extends DID implements ISigner {
     /**
      * Sign a message
      *
-     * @param {Uint8Array<ArrayBuffer>} message
+     * @param {Uint8Array} message
      */
-    sign(message: Uint8Array<ArrayBuffer>): Promise<Uint8Array<ArrayBuffer>>;
+    sign(message: Uint8Array): Promise<import("@noble/secp256k1").Bytes>;
     /**
      * Export the signer as a encoded string
      */

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

@@ -1 +1 @@
-{"version":3,"file":"es256k.d.ts","sourceRoot":"","sources":["../../../src/signers/es256k.js"],"names":[],"mappings":"AAoBA;;;;GAIG;AACH,iDAFgB,OAAO;IAGrB;;;;OAIG;IACH,aAFU,MAAM,CAEI;IAoBpB;;;;OAIG;IACH,wBAFW,UAAU,CAAC,WAAW,CAAC,gBAajC;IAED;;;;;OAKG;IACH,sBAHW,OAAO,eAAe,EAAE,YAAY,QACpC,OAAO,eAAe,EAAE,aAAa,gBAc/C;IAED;;;;;OAKG;IACH,uBAHW,MAAM,QACN,OAAO,eAAe,EAAE,aAAa,gBAc/C;IApED;;;;OAIG;IACH,iBAHW,OAAO,eAAe,EAAE,aAAa,cACrC,UAAU,EAOpB;IAhBD,kDAAkD;IAClD,eADW,OAAO,aAAa,EAAE,aAAa,CACjC;IA2Eb;;;;OAIG;IACH,cAFW,UAAU,CAAC,WAAW,CAAC,oCAKjC;IAED;;OAEG;IACH,iBAEC;;CAKF;sBAzHY,OAAO,aAAa,EAAE,OAAO,CAAC,MAAM,CAAC;oBAL9B,SAAS"}
+{"version":3,"file":"es256k.d.ts","sourceRoot":"","sources":["../../../src/signers/es256k.js"],"names":[],"mappings":"AAoBA;;;;GAIG;AACH,iDAFgB,OAAO;IAGrB;;;;OAIG;IACH,aAFU,MAAM,CAEI;IAoBpB;;;;OAIG;IACH,wBAFW,UAAU,gBAUpB;IAED;;;;;OAKG;IACH,sBAHW,OAAO,eAAe,EAAE,YAAY,QACpC,OAAO,eAAe,EAAE,aAAa,gBAU/C;IAED;;;;;OAKG;IACH,uBAHW,MAAM,QACN,OAAO,eAAe,EAAE,aAAa,gBAU/C;IAzDD;;;;OAIG;IACH,iBAHW,OAAO,eAAe,EAAE,aAAa,cACrC,UAAU,EAOpB;IAhBD,kDAAkD;IAClD,eADW,OAAO,aAAa,EAAE,aAAa,CACjC;IAgEb;;;;OAIG;IACH,cAFW,UAAU,6CAKpB;IAED;;OAEG;IACH,iBAEC;;CAKF;sBA9GY,OAAO,aAAa,EAAE,OAAO,CAAC,MAAM,CAAC;oBAL9B,SAAS"}

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

@@ -33,9 +33,9 @@ export class RSASigner extends DID implements ISigner {
     /**
      * Sign a message
      *
-     * @param {Uint8Array<ArrayBuffer>} message
+     * @param {Uint8Array} message
      */
-    sign(message: Uint8Array<ArrayBuffer>): Promise<Uint8Array<ArrayBuffer>>;
+    sign(message: Uint8Array): Promise<Uint8Array<ArrayBufferLike>>;
     /**
      * Export the signer as a crypto key pair
      */

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

@@ -1 +1 @@
-{"version":3,"file":"rsa.d.ts","sourceRoot":"","sources":["../../../src/signers/rsa.js"],"names":[],"mappings":"AAsBA;;;;GAIG;AACH,8CAFgB,OAAO;IAIrB,oBAAoB;IAmBpB;;OAEG;IACH,sCAqBC;IAED;;;;;OAKG;IACH,sBAHW,OAAO,eAAe,EAAE,aAAa,QACrC,OAAO,eAAe,EAAE,aAAa,sBA+B/C;IAED;;;;;OAKG;IACH,uBAHW,aAAa,QACb,OAAO,eAAe,EAAE,aAAa,sBAc/C;IA5FD;;;OAGG;IACH,iBAHW,OAAO,eAAe,EAAE,aAAa,WACrC,aAAa,EAOvB;IAZD,kDAAkD;IAClD,eADW,OAAO,aAAa,EAAE,aAAa,CACjC;IAgGb;;;;OAIG;IACH,cAFW,UAAU,CAAC,WAAW,CAAC,oCAUjC;IAED;;OAEG;IACH,wBAEC;;CAKF;sBAnJY,OAAO,aAAa,EAAE,OAAO,CAAC,aAAa,CAAC;oBANrC,SAAS"}
+{"version":3,"file":"rsa.d.ts","sourceRoot":"","sources":["../../../src/signers/rsa.js"],"names":[],"mappings":"AAsBA;;;;GAIG;AACH,8CAFgB,OAAO;IAIrB,oBAAoB;IAmBpB;;OAEG;IACH,sCAqBC;IAED;;;;;OAKG;IACH,sBAHW,OAAO,eAAe,EAAE,aAAa,QACrC,OAAO,eAAe,EAAE,aAAa,sBA+B/C;IAED;;;;;OAKG;IACH,uBAHW,aAAa,QACb,OAAO,eAAe,EAAE,aAAa,sBAc/C;IA5FD;;;OAGG;IACH,iBAHW,OAAO,eAAe,EAAE,aAAa,WACrC,aAAa,EAOvB;IAZD,kDAAkD;IAClD,eADW,OAAO,aAAa,EAAE,aAAa,CACjC;IAgGb;;;;OAIG;IACH,cAFW,UAAU,wCAUpB;IAED;;OAEG;IACH,wBAEC;;CAKF;sBAnJY,OAAO,aAAa,EAAE,OAAO,CAAC,aAAa,CAAC;oBANrC,SAAS"}

package/dist/src/spki.d.ts

@@ -3,12 +3,12 @@ export namespace spki {
     export { decode };
 }
 /**
- * @param {Uint8Array<ArrayBuffer>} key
+ * @param {Uint8Array} key
  */
-declare function encode(key: Uint8Array<ArrayBuffer>): Uint8Array<ArrayBuffer>;
+declare function encode(key: Uint8Array): Uint8Array<ArrayBuffer>;
 /**
- * @param {Uint8Array<ArrayBuffer>} info
+ * @param {Uint8Array} info
  */
-declare function decode(info: Uint8Array<ArrayBuffer>): Uint8Array<ArrayBuffer>;
+declare function decode(info: Uint8Array): Uint8Array<ArrayBufferLike>;
 export {};
 //# sourceMappingURL=spki.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"spki.d.ts","sourceRoot":"","sources":["../../src/spki.js"],"names":[],"mappings":";;;;AAgBA;;GAEG;AACH,6BAFW,UAAU,CAAC,WAAW,CAAC,2BAIjC;AAED;;GAEG;AACH,8BAFW,UAAU,CAAC,WAAW,CAAC,2BAUjC"}
+{"version":3,"file":"spki.d.ts","sourceRoot":"","sources":["../../src/spki.js"],"names":[],"mappings":";;;;AAgBA;;GAEG;AACH,6BAFW,UAAU,2BAIpB;AAED;;GAEG;AACH,8BAFW,UAAU,+BAUpB"}

package/dist/src/types.d.ts

@@ -1,15 +1,15 @@
 import type { VerifiableDID } from 'iso-did/types';
 export type SignatureType = 'Ed25519' | 'ES256' | 'ES384' | 'ES512' | 'ES256K' | 'RS256' | 'EIP191';
 export interface Sign {
-    sign: (message: Uint8Array<ArrayBuffer>) => Promise<Uint8Array<ArrayBuffer>>;
+    sign: (message: Uint8Array) => Promise<Uint8Array>;
 }
 export interface ISigner<Export extends CryptoKeyPair | string = string> extends VerifiableDID, Sign {
     export: () => Export;
     signatureType: SignatureType;
 }
 export interface VerifyInput {
-    signature: Uint8Array<ArrayBuffer>;
-    message: Uint8Array<ArrayBuffer>;
+    signature: Uint8Array;
+    message: Uint8Array;
     did: VerifiableDID;
 }
 export type Verify = (input: VerifyInput) => Promise<boolean>;

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,aAAa,EAAE,MAAM,eAAe,CAAA;AAElD,MAAM,MAAM,aAAa,GACrB,SAAS,GACT,OAAO,GACP,OAAO,GACP,OAAO,GACP,QAAQ,GACR,OAAO,GACP,QAAQ,CAAA;AAEZ,MAAM,WAAW,IAAI;IACnB,IAAI,EAAE,CAAC,OAAO,EAAE,UAAU,CAAC,WAAW,CAAC,KAAK,OAAO,CAAC,UAAU,CAAC,WAAW,CAAC,CAAC,CAAA;CAC7E;AAED,MAAM,WAAW,OAAO,CAAC,MAAM,SAAS,aAAa,GAAG,MAAM,GAAG,MAAM,CACrE,SAAQ,aAAa,EACnB,IAAI;IACN,MAAM,EAAE,MAAM,MAAM,CAAA;IACpB,aAAa,EAAE,aAAa,CAAA;CAC7B;AAED,MAAM,WAAW,WAAW;IAC1B,SAAS,EAAE,UAAU,CAAC,WAAW,CAAC,CAAA;IAClC,OAAO,EAAE,UAAU,CAAC,WAAW,CAAC,CAAA;IAChC,GAAG,EAAE,aAAa,CAAA;CACnB;AACD,MAAM,MAAM,MAAM,GAAG,CAAC,KAAK,EAAE,WAAW,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;AAE7D,MAAM,MAAM,QAAQ,CAAC,CAAC,SAAS,aAAa,IAAI,MAAM,CAAC,CAAC,EAAE,MAAM,CAAC,CAAA;AAEjE,MAAM,MAAM,gBAAgB,CAAC,CAAC,SAAS,aAAa,IAAI,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAA;AAE5E,MAAM,WAAW,mBAAoB,SAAQ,WAAW;IACtD;;OAEG;IACH,IAAI,EAAE,aAAa,CAAA;CACpB;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"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAA;AAElD,MAAM,MAAM,aAAa,GACrB,SAAS,GACT,OAAO,GACP,OAAO,GACP,OAAO,GACP,QAAQ,GACR,OAAO,GACP,QAAQ,CAAA;AAEZ,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,GAAG,MAAM,CACrE,SAAQ,aAAa,EACnB,IAAI;IACN,MAAM,EAAE,MAAM,MAAM,CAAA;IACpB,aAAa,EAAE,aAAa,CAAA;CAC7B;AAED,MAAM,WAAW,WAAW;IAC1B,SAAS,EAAE,UAAU,CAAA;IACrB,OAAO,EAAE,UAAU,CAAA;IACnB,GAAG,EAAE,aAAa,CAAA;CACnB;AACD,MAAM,MAAM,MAAM,GAAG,CAAC,KAAK,EAAE,WAAW,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;AAE7D,MAAM,MAAM,QAAQ,CAAC,CAAC,SAAS,aAAa,IAAI,MAAM,CAAC,CAAC,EAAE,MAAM,CAAC,CAAA;AAEjE,MAAM,MAAM,gBAAgB,CAAC,CAAC,SAAS,aAAa,IAAI,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAA;AAE5E,MAAM,WAAW,mBAAoB,SAAQ,WAAW;IACtD;;OAEG;IACH,IAAI,EAAE,aAAa,CAAA;CACpB;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

@@ -1,8 +1,8 @@
 /**
  *
  * @param {import('iso-did/types').KeyType} type
- * @param {BufferSource} publicKey
+ * @param {Uint8Array} 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): import("iso-did/types").VerifiableDID;
+export function didKeyOrVerifiableDID(type: import("iso-did/types").KeyType, publicKey: Uint8Array, did?: import("iso-did/types").VerifiableDID): 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":"AAGA;;;;;GAKG;AACH,4CAJW,OAAO,eAAe,EAAE,OAAO,aAC/B,YAAY,QACZ,OAAO,eAAe,EAAE,aAAa,yCAqB/C"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/utils.js"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,4CAJW,OAAO,eAAe,EAAE,OAAO,aAC/B,UAAU,QACV,OAAO,eAAe,EAAE,aAAa,yCAqB/C"}

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

@@ -3,11 +3,11 @@
  *
  * @param {`0x${string}`} signature
  */
-export function hexToBytes(signature: `0x${string}`): Uint8Array<ArrayBuffer>;
+export function hexToBytes(signature: `0x${string}`): Uint8Array<ArrayBufferLike>;
 /**
- * @param {Uint8Array<ArrayBuffer>} data
+ * @param {Uint8Array} data
  */
-export function getSignPayload(data: Uint8Array<ArrayBuffer>): Uint8Array<ArrayBufferLike>;
+export function getSignPayload(data: Uint8Array): Uint8Array<ArrayBufferLike>;
 export function verify(input: import("../types.js").VerifyInput): Promise<boolean>;
 /** @type {import('../types').Verifier<'EIP191'>} */
 export const verifier: import("../types").Verifier<"EIP191">;

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

@@ -1 +1 @@
-{"version":3,"file":"eip191.d.ts","sourceRoot":"","sources":["../../../src/verifiers/eip191.js"],"names":[],"mappings":"AASA;;;;GAIG;AACH,sCAFW,KAAK,MAAM,EAAE,2BAIvB;AAED;;GAEG;AACH,qCAFW,UAAU,CAAC,WAAW,CAAC,+BAKjC;;AAkBD,oDAAoD;AACpD,uBADW,OAAO,UAAU,EAAE,QAAQ,CAAC,QAAQ,CAAC,CAG/C"}
+{"version":3,"file":"eip191.d.ts","sourceRoot":"","sources":["../../../src/verifiers/eip191.js"],"names":[],"mappings":"AASA;;;;GAIG;AACH,sCAFW,KAAK,MAAM,EAAE,+BAIvB;AAED;;GAEG;AACH,qCAFW,UAAU,+BAKpB;;AAkBD,oDAAoD;AACpD,uBADW,OAAO,UAAU,EAAE,QAAQ,CAAC,QAAQ,CAAC,CAG/C"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "iso-signatures",
   "type": "module",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "description": "Signatures tooling.",
   "author": "Hugo Dias <hugomrdias@gmail.com> (hugodias.me)",
   "license": "MIT",
@@ -84,20 +84,20 @@
     "@noble/ed25519": "^3.0.0",
     "@noble/hashes": "^2.0.0",
     "@noble/secp256k1": "^3.0.0",
-    "ox": "^0.9.1",
-    "iso-base": "^4.2.0",
-    "iso-did": "^2.1.0"
+    "ox": "^0.9.6",
+    "iso-base": "^4.2.1",
+    "iso-did": "^2.1.1"
   },
   "devDependencies": {
     "@types/assert": "^1.5.11",
     "@types/mocha": "^10.0.10",
-    "@types/node": "^24.3.0",
+    "@types/node": "^24.5.2",
     "assert": "^2.1.0",
-    "mocha": "^11.7.1",
+    "mocha": "^11.7.2",
     "playwright-test": "^14.1.12",
-    "type-fest": "^4.34.1",
+    "type-fest": "^5.0.1",
     "typescript": "5.9.2",
-    "viem": "^2.35.1"
+    "viem": "^2.37.6"
   },
   "publishConfig": {
     "provenance": true

package/src/asn1.js

@@ -30,7 +30,7 @@ export const encodeDERLength = (length) => {
 }
 
 /**
- * @param {Uint8Array<ArrayBuffer>} bytes
+ * @param {Uint8Array} bytes
  * @param {number} offset
  */
 export const readDERLength = (bytes, offset = 0) => {
@@ -56,7 +56,7 @@ export const readDERLength = (bytes, offset = 0) => {
 }
 
 /**
- * @param {Uint8Array<ArrayBuffer>} input
+ * @param {Uint8Array} input
  * @param {number} expectedTag
  * @param {number} position
  */
@@ -66,7 +66,7 @@ export const skip = (input, expectedTag, position) => {
 }
 
 /**
- * @param {Uint8Array<ArrayBuffer>} input
+ * @param {Uint8Array} input
  * @param {number} expectedTag
  * @param {number} offset
  */
@@ -90,7 +90,7 @@ export const into = (input, expectedTag, offset) => {
 }
 
 /**
- * @param {Uint8Array<ArrayBuffer>} input
+ * @param {Uint8Array} input
  */
 export const encodeBitString = (input) => {
   // encode input length + 1 for unused bit pad
@@ -123,7 +123,7 @@ export const encodeBitString = (input) => {
 }
 
 /**
- * @param {Uint8Array<ArrayBuffer>} input
+ * @param {Uint8Array} input
  */
 export const encodeOctetString = (input) => {
   // encode input length
@@ -147,7 +147,7 @@ export const encodeOctetString = (input) => {
 }
 
 /**
- * @param {Uint8Array<ArrayBuffer>[]} sequence
+ * @param {Uint8Array[]} sequence
  */
 export const encodeSequence = (sequence) => {
   // calculate bytelength for all the parts
@@ -182,7 +182,7 @@ export const encodeSequence = (sequence) => {
 }
 
 /**
- * @param {Uint8Array<ArrayBuffer>} bytes
+ * @param {Uint8Array} bytes
  * @param {number} offset
  */
 export const readSequence = (bytes, offset = 0) => {
@@ -192,7 +192,7 @@ export const readSequence = (bytes, offset = 0) => {
 }
 
 /**
- * @param {Uint8Array<ArrayBuffer>} input
+ * @param {Uint8Array} input
  */
 export const encodeInt = (input) => {
   const extra = input.byteLength === 0 || input[0] & 0x80 ? 1 : 0
@@ -229,7 +229,7 @@ export const encodeInt = (input) => {
 }
 
 /**
- * @param {Uint8Array<ArrayBuffer>} bytes
+ * @param {Uint8Array} bytes
  * @param {number} offset
  */
 
@@ -237,20 +237,20 @@ export const enterSequence = (bytes, offset = 0) =>
   into(bytes, SEQUENCE_TAG, offset).position
 
 /**
- * @param {Uint8Array<ArrayBuffer>} bytes
+ * @param {Uint8Array} bytes
  * @param {number} offset
  */
 export const skipSequence = (bytes, offset = 0) =>
   skip(bytes, SEQUENCE_TAG, offset)
 
 /**
- * @param {Uint8Array<ArrayBuffer>} bytes
+ * @param {Uint8Array} bytes
  * @param {number} offset
  */
 export const skipInt = (bytes, offset = 0) => skip(bytes, INT_TAG, offset)
 
 /**
- * @param {Uint8Array<ArrayBuffer>} bytes
+ * @param {Uint8Array} bytes
  */
 export const readBitString = (bytes, offset = 0) => {
   const { position, length } = into(bytes, BITSTRING_TAG, offset)
@@ -270,7 +270,7 @@ export const readBitString = (bytes, offset = 0) => {
 }
 
 /**
- * @param {Uint8Array<ArrayBuffer>} bytes
+ * @param {Uint8Array} bytes
  * @param {number} byteOffset
  */
 export const readInt = (bytes, byteOffset = 0) => {
@@ -290,7 +290,7 @@ export const readInt = (bytes, byteOffset = 0) => {
 }
 
 /**
- * @param {Uint8Array<ArrayBuffer>} bytes
+ * @param {Uint8Array} bytes
  * @param {number} offset
  */
 export const readOctetString = (bytes, offset = 0) => {
@@ -300,9 +300,9 @@ export const readOctetString = (bytes, offset = 0) => {
 }
 
 /**
- * @typedef {(bytes:Uint8Array<ArrayBuffer>, offset:number) => Uint8Array<ArrayBuffer>} Reader
+ * @typedef {(bytes:Uint8Array, offset:number) => Uint8Array} Reader
  * @param {[Reader, ...Reader[]]} readers
- * @param {Uint8Array<ArrayBuffer>} source
+ * @param {Uint8Array} source
  * @param {number} byteOffset
  */
 export const readSequenceWith = (readers, source, byteOffset = 0) => {

package/src/signers/ecdsa.js

@@ -150,7 +150,7 @@ export class ECDSASigner extends DID {
 
     const publicKey = await webcrypto.subtle.exportKey('raw', publicKeyJWK)
 
-    return new ECDSASigner(didKeyOrVerifiableDID(type, publicKey, did), {
+    return new ECDSASigner(didKeyOrVerifiableDID(type, u8(publicKey), did), {
       privateKey,
       publicKey: publicKeyJWK,
     })
@@ -186,19 +186,22 @@ export class ECDSASigner extends DID {
       }
     }
 
-    return new ECDSASigner(didKeyOrVerifiableDID(curve, publicKey, did), key)
+    return new ECDSASigner(
+      didKeyOrVerifiableDID(curve, u8(publicKey), did),
+      key
+    )
   }
 
   /**
    * Sign a message
    *
-   * @param {Uint8Array<ArrayBuffer>} message
+   * @param {Uint8Array} message
    */
   async sign(message) {
     const buf = await webcrypto.subtle.sign(
       this.#params,
       this.#keypair.privateKey,
-      message
+      /** @type {BufferSource} */ (message)
     )
 
     return u8(buf)

package/src/signers/eddsa.js

@@ -70,10 +70,7 @@ export class EdDSASigner extends DID {
       publicKey = key.publicKey
     }
     return new EdDSASigner(
-      DIDKey.fromPublicKey(
-        'Ed25519',
-        /** @type {Uint8Array<ArrayBuffer>} */ (publicKey)
-      ),
+      DIDKey.fromPublicKey('Ed25519', publicKey),
       privateKey
     )
   }
@@ -89,11 +86,7 @@ export class EdDSASigner extends DID {
     const publicKey = await getPublicKeyAsync(privateKey)
 
     return new EdDSASigner(
-      didKeyOrVerifiableDID(
-        'Ed25519',
-        /** @type {Uint8Array<ArrayBuffer>} */ (publicKey),
-        did
-      ),
+      didKeyOrVerifiableDID('Ed25519', publicKey, did),
       privateKey
     )
   }
@@ -117,12 +110,10 @@ export class EdDSASigner extends DID {
   /**
    * Sign a message
    *
-   * @param {Uint8Array<ArrayBuffer>} message
+   * @param {Uint8Array} message
    */
   sign(message) {
-    return /** @type {Promise<Uint8Array<ArrayBuffer>>} */ (
-      signAsync(message, this.#privateKey)
-    )
+    return signAsync(message, this.#privateKey)
   }
 
   /**

package/src/signers/eip191.js

@@ -72,7 +72,7 @@ export class EIP191Signer extends DID {
   /**
    * Sign a message
    *
-   * @param {Uint8Array<ArrayBuffer>} message
+   * @param {Uint8Array} message
    */
   async sign(message) {
     const result = await this.provider.request({

package/src/signers/es256k.js

@@ -52,17 +52,14 @@ export class ES256KSigner extends DID {
   /**
    * Generate a new signer
    *
-   * @param {Uint8Array<ArrayBuffer>} [bytes]
+   * @param {Uint8Array} [bytes]
    */
   static generate(bytes) {
     const privateKey = bytes || utils.randomSecretKey()
     const publicKey = getPublicKey(privateKey)
 
     return new ES256KSigner(
-      DIDKey.fromPublicKey(
-        'secp256k1',
-        /** @type {Uint8Array<ArrayBuffer>} */ (publicKey)
-      ),
+      DIDKey.fromPublicKey('secp256k1', publicKey),
       privateKey
     )
   }
@@ -78,11 +75,7 @@ export class ES256KSigner extends DID {
     const publicKey = getPublicKey(privateKey)
 
     return new ES256KSigner(
-      didKeyOrVerifiableDID(
-        'secp256k1',
-        /** @type {Uint8Array<ArrayBuffer>} */ (publicKey),
-        did
-      ),
+      didKeyOrVerifiableDID('secp256k1', publicKey, did),
       privateKey
     )
   }
@@ -98,11 +91,7 @@ export class ES256KSigner extends DID {
     const publicKey = getPublicKey(privateKey)
 
     return new ES256KSigner(
-      didKeyOrVerifiableDID(
-        'secp256k1',
-        /** @type {Uint8Array<ArrayBuffer>} */ (publicKey),
-        did
-      ),
+      didKeyOrVerifiableDID('secp256k1', publicKey, did),
       privateKey
     )
   }
@@ -110,11 +99,11 @@ export class ES256KSigner extends DID {
   /**
    * Sign a message
    *
-   * @param {Uint8Array<ArrayBuffer>} message
+   * @param {Uint8Array} message
    */
   async sign(message) {
     const sig = await signAsync(message, this.#privateKey)
-    return /** @type {Uint8Array<ArrayBuffer>} */ (sig)
+    return sig
   }
 
   /**

package/src/signers/rsa.js

@@ -132,13 +132,13 @@ export class RSASigner extends DID {
   /**
    * Sign a message
    *
-   * @param {Uint8Array<ArrayBuffer>} message
+   * @param {Uint8Array} message
    */
   async sign(message) {
     const buf = await webcrypto.subtle.sign(
       { name: 'RSASSA-PKCS1-v1_5', saltLength: 128 },
       this.#keypair.privateKey,
-      message
+      /** @type {BufferSource} */ (message)
     )
 
     return u8(buf)

package/src/spki.js

@@ -15,14 +15,14 @@ const SPKI_PARAMS_ENCODED = new Uint8Array([
 ])
 
 /**
- * @param {Uint8Array<ArrayBuffer>} key
+ * @param {Uint8Array} key
  */
 function encode(key) {
   return encodeSequence([SPKI_PARAMS_ENCODED, encodeBitString(key)])
 }
 
 /**
- * @param {Uint8Array<ArrayBuffer>} info
+ * @param {Uint8Array} info
  */
 function decode(info) {
   // go into the top-level SEQUENCE

package/src/types.ts

@@ -10,7 +10,7 @@ export type SignatureType =
   | 'EIP191'
 
 export interface Sign {
-  sign: (message: Uint8Array<ArrayBuffer>) => Promise<Uint8Array<ArrayBuffer>>
+  sign: (message: Uint8Array) => Promise<Uint8Array>
 }
 
 export interface ISigner<Export extends CryptoKeyPair | string = string>
@@ -21,8 +21,8 @@ export interface ISigner<Export extends CryptoKeyPair | string = string>
 }
 
 export interface VerifyInput {
-  signature: Uint8Array<ArrayBuffer>
-  message: Uint8Array<ArrayBuffer>
+  signature: Uint8Array
+  message: Uint8Array
   did: VerifiableDID
 }
 export type Verify = (input: VerifyInput) => Promise<boolean>

package/src/utils.js

@@ -1,15 +1,15 @@
-import { equals, u8 } from 'iso-base/utils'
+import { equals } from 'iso-base/utils'
 import { DIDKey } from 'iso-did/key'
 
 /**
  *
  * @param {import('iso-did/types').KeyType} type
- * @param {BufferSource} publicKey
+ * @param {Uint8Array} 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))
+  let _did = DIDKey.fromPublicKey(type, publicKey)
   if (did) {
     if (!equals(did.verifiableDid.publicKey, _did.verifiableDid.publicKey)) {
       throw new Error('Public key mismatch')

package/src/verifiers/ecdsa.js

@@ -19,7 +19,7 @@ function createVerifier(curve) {
 
     const key = await webcrypto.subtle.importKey(
       'raw',
-      publicKey,
+      /** @type {BufferSource} */ (publicKey),
       { name: params.name, namedCurve: params.namedCurve },
       true,
       ['verify']
@@ -31,8 +31,8 @@ function createVerifier(curve) {
         hash: { name: params.hash },
       },
       key,
-      signature,
-      message
+      /** @type {BufferSource} */ (signature),
+      /** @type {BufferSource} */ (message)
     )
   }
 

package/src/verifiers/eip191.js

@@ -1,4 +1,4 @@
-import { keccak_256 } from '@noble/hashes/sha3'
+import { keccak_256 } from '@noble/hashes/sha3.js'
 import { recoverPublicKeyAsync, Signature, verifyAsync } from '@noble/secp256k1'
 import { hex } from 'iso-base/rfc4648'
 import { utf8 } from 'iso-base/utf8'
@@ -17,7 +17,7 @@ export function hexToBytes(signature) {
 }
 
 /**
- * @param {Uint8Array<ArrayBuffer>} data
+ * @param {Uint8Array} data
  */
 export function getSignPayload(data) {
   const prefixBytes = utf8.decode(`${PREFIX}${data.length}`)

package/src/verifiers/rsa.js

@@ -14,8 +14,8 @@ export async function verify({ signature, message, did }) {
   return await webcrypto.subtle.verify(
     { name: 'RSASSA-PKCS1-v1_5', saltLength: 128 },
     key,
-    signature,
-    message
+    /** @type {BufferSource} */ (signature),
+    /** @type {BufferSource} */ (message)
   )
 }