iso-signatures 0.4.0 → 0.5.0

package/dist/src/asn1.d.ts

@@ -5,27 +5,27 @@ export const NULL_TAG: 5;
 export const OBJECT_TAG: 6;
 export const SEQUENCE_TAG: 48;
 export const UNUSED_BIT_PAD: 0;
-export function encodeDERLength(length: number): Uint8Array;
-export function readDERLength(bytes: Uint8Array, offset?: number): {
+export function encodeDERLength(length: number): Uint8Array<ArrayBuffer>;
+export function readDERLength(bytes: Uint8Array<ArrayBuffer>, offset?: number): {
     number: number;
     consumed: number;
 };
-export function skip(input: Uint8Array, expectedTag: number, position: number): number;
-export function into(input: Uint8Array, expectedTag: number, offset: number): {
+export function skip(input: Uint8Array<ArrayBuffer>, expectedTag: number, position: number): number;
+export function into(input: Uint8Array<ArrayBuffer>, expectedTag: number, offset: number): {
     position: number;
     length: number;
 };
-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;
-export function readInt(bytes: Uint8Array, byteOffset?: number): Uint8Array;
-export function readOctetString(bytes: Uint8Array, offset?: number): Uint8Array;
-export function readSequenceWith(readers: [Reader, ...Reader[]], source: Uint8Array, byteOffset?: number): Uint8Array<ArrayBufferLike>[];
-export type Reader = (bytes: Uint8Array, offset: number) => Uint8Array;
+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>;
 //# 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;AAM3B,wCAHI,MAAM,GACJ,UAAU,CAetB;AAOM,qCAJI,UAAU,WACV,MAAM,GACJ;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAC,CAsB9C;AAQM,4BALI,UAAU,eACV,MAAM,YACN,MAAM,GACJ,MAAM,CAKlB;AAQM,4BALI,UAAU,eACV,MAAM,UACN,MAAM,GACJ;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAmBhD;AAKM,uCAFI,UAAU,2BA8BpB;AAKM,yCAFI,UAAU,2BAqBpB;AAKM,yCAFI,UAAU,EAAE,2BAgCtB;AAMM,oCAHI,UAAU,WACV,MAAM,+BAMhB;AAKM,iCAFI,UAAU,2BAkCpB;AAQM,qCALI,UAAU,WACV,MAAM,GACJ,MAAM,CAIyB;AAOrC,oCAJI,UAAU,WACV,MAAM,GACJ,MAAM,CAGgB;AAO5B,+BAJI,UAAU,WACV,MAAM,GACJ,MAAM,CAEuD;AAOnE,qCAJI,UAAU,WACV,MAAM,GACJ,UAAU,CAiBtB;AAOM,+BAJI,UAAU,eACV,MAAM,GACJ,UAAU,CAgBtB;AAOM,uCAJI,UAAU,WACV,MAAM,GACJ,UAAU,CAMtB;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"}
+{"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"}

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

@@ -46,9 +46,9 @@ export class ECDSASigner extends DID implements ISigner {
     /**
      * Sign a message
      *
-     * @param {Uint8Array} message
+     * @param {Uint8Array<ArrayBuffer>} message
      */
-    sign(message: Uint8Array): Promise<Uint8Array<ArrayBufferLike>>;
+    sign(message: Uint8Array<ArrayBuffer>): Promise<Uint8Array<ArrayBuffer>>;
     /**
      * 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,wCAUpB;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,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"}

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

@@ -40,9 +40,9 @@ export class EdDSASigner extends DID implements ISigner {
     /**
      * Sign a message
      *
-     * @param {Uint8Array} message
+     * @param {Uint8Array<ArrayBuffer>} message
      */
-    sign(message: Uint8Array): Promise<import("@noble/ed25519").Bytes>;
+    sign(message: Uint8Array<ArrayBuffer>): Promise<Uint8Array<ArrayBuffer>>;
     /**
      * 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":"AA0BA;;;;GAIG;AACH,gDAFgB,OAAO;IAGrB;;;;OAIG;IACH,aAFU,MAAM,CAEI;IAmBpB;;;;OAIG;IACH,wBAFW,UAAU,wBASpB;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;IAvDD;;;OAGG;IACH,iBAHW,OAAO,eAAe,EAAE,aAAa,cACrC,UAAU,EAOpB;IAZD,kDAAkD;IAClD,eADW,OAAO,aAAa,EAAE,aAAa,CACjC;IA2Db;;;;OAIG;IACH,cAFW,UAAU,2CAIpB;IAED;;OAEG;IACH,iBAEC;;CAKF;sBA5GY,OAAO,aAAa,EAAE,OAAO,CAAC,MAAM,CAAC;oBAR9B,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,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"}

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

@@ -534,9 +534,9 @@ export class EIP191Signer extends DID implements ISigner {
     /**
      * Sign a message
      *
-     * @param {Uint8Array} message
+     * @param {Uint8Array<ArrayBuffer>} message
      */
-    sign(message: Uint8Array): Promise<Uint8Array<ArrayBufferLike>>;
+    sign(message: Uint8Array<ArrayBuffer>): Promise<Uint8Array<ArrayBuffer>>;
     /**
      * 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;;;;;;;;;;;;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"}
+{"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"}

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

@@ -13,9 +13,9 @@ export class ES256KSigner extends DID implements ISigner {
     /**
      * Generate a new signer
      *
-     * @param {Uint8Array} [bytes]
+     * @param {Uint8Array<ArrayBuffer>} [bytes]
      */
-    static generate(bytes?: Uint8Array): ES256KSigner;
+    static generate(bytes?: Uint8Array<ArrayBuffer>): ES256KSigner;
     /**
      * Import a signer from a JWK
      *
@@ -41,9 +41,9 @@ export class ES256KSigner extends DID implements ISigner {
     /**
      * Sign a message
      *
-     * @param {Uint8Array} message
+     * @param {Uint8Array<ArrayBuffer>} message
      */
-    sign(message: Uint8Array): Promise<import("@noble/secp256k1").Bytes>;
+    sign(message: Uint8Array<ArrayBuffer>): Promise<Uint8Array<ArrayBuffer>>;
     /**
      * 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":"AAqBA;;;;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,6CAMpB;IAED;;OAEG;IACH,iBAEC;;CAKF;sBA/GY,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,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"}

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

@@ -33,9 +33,9 @@ export class RSASigner extends DID implements ISigner {
     /**
      * Sign a message
      *
-     * @param {Uint8Array} message
+     * @param {Uint8Array<ArrayBuffer>} message
      */
-    sign(message: Uint8Array): Promise<Uint8Array<ArrayBufferLike>>;
+    sign(message: Uint8Array<ArrayBuffer>): Promise<Uint8Array<ArrayBuffer>>;
     /**
      * 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,wCAUpB;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,CAAC,WAAW,CAAC,oCAUjC;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} key
+ * @param {Uint8Array<ArrayBuffer>} key
  */
-declare function encode(key: Uint8Array): Uint8Array<ArrayBuffer>;
+declare function encode(key: Uint8Array<ArrayBuffer>): Uint8Array<ArrayBuffer>;
 /**
- * @param {Uint8Array} info
+ * @param {Uint8Array<ArrayBuffer>} info
  */
-declare function decode(info: Uint8Array): Uint8Array<ArrayBufferLike>;
+declare function decode(info: Uint8Array<ArrayBuffer>): Uint8Array<ArrayBuffer>;
 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,2BAIpB;AAED;;GAEG;AACH,8BAFW,UAAU,+BAUpB"}
+{"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"}

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) => Promise<Uint8Array>;
+    sign: (message: Uint8Array<ArrayBuffer>) => Promise<Uint8Array<ArrayBuffer>>;
 }
 export interface ISigner<Export extends CryptoKeyPair | string = string> extends VerifiableDID, Sign {
     export: () => Export;
     signatureType: SignatureType;
 }
 export interface VerifyInput {
-    signature: Uint8Array;
-    message: Uint8Array;
+    signature: Uint8Array<ArrayBuffer>;
+    message: Uint8Array<ArrayBuffer>;
     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,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"}
+{"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"}

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

@@ -1 +1 @@
-{"version":3,"file":"ecdsa.d.ts","sourceRoot":"","sources":["../../../src/verifiers/ecdsa.js"],"names":[],"mappings":"AA4DA;;;;;GAKG;AACH,6BAJW,OAAO,GAAG,OAAO,GAAG,OAAO,GAAG,QAAQ,+BACtC,OAAO,aAAa,EAAE,WAAW,oBAK3C;AAhBD,qFAAqF;AACrF,uBADW,OAAO,aAAa,EAAE,QAAQ,CAAC,OAAO,GAAG,OAAO,GAAG,OAAO,GAAG,QAAQ,CAAC,CAMhF"}
+{"version":3,"file":"ecdsa.d.ts","sourceRoot":"","sources":["../../../src/verifiers/ecdsa.js"],"names":[],"mappings":"AAyDA;;;;;GAKG;AACH,6BAJW,OAAO,GAAG,OAAO,GAAG,OAAO,GAAG,QAAQ,+BACtC,OAAO,aAAa,EAAE,WAAW,oBAK3C;AAhBD,qFAAqF;AACrF,uBADW,OAAO,aAAa,EAAE,QAAQ,CAAC,OAAO,GAAG,OAAO,GAAG,OAAO,GAAG,QAAQ,CAAC,CAMhF"}

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

@@ -2,13 +2,12 @@
  * Convert a 0x signature to a Uint8Array
  *
  * @param {`0x${string}`} signature
- * @returns {Uint8Array}
  */
-export function hexToBytes(signature: `0x${string}`): Uint8Array;
+export function hexToBytes(signature: `0x${string}`): Uint8Array<ArrayBuffer>;
 /**
- * @param { Uint8Array} data
+ * @param {Uint8Array<ArrayBuffer>} data
  */
-export function getSignPayload(data: Uint8Array): Uint8Array<ArrayBufferLike>;
+export function getSignPayload(data: Uint8Array<ArrayBuffer>): 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":"AAYA;;;;;GAKG;AACH,sCAHW,KAAK,MAAM,EAAE,GACX,UAAU,CAItB;AAED;;GAEG;AACH,qCAFY,UAAU,+BAKrB;;AAeD,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,2BAIvB;AAED;;GAEG;AACH,qCAFW,UAAU,CAAC,WAAW,CAAC,+BAKjC;;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.4.0",
+  "version": "0.5.0",
   "description": "Signatures tooling.",
   "author": "Hugo Dias <hugomrdias@gmail.com> (hugodias.me)",
   "license": "MIT",
@@ -81,23 +81,23 @@
     "dist/src/**/*.d.ts.map"
   ],
   "dependencies": {
-    "@noble/ed25519": "^2.3.0",
-    "@noble/hashes": "^1.8.0",
-    "@noble/secp256k1": "^2.3.0",
-    "ox": "^0.8.5",
-    "iso-base": "^4.1.0",
-    "iso-did": "^2.0.0"
+    "@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"
   },
   "devDependencies": {
     "@types/assert": "^1.5.11",
     "@types/mocha": "^10.0.10",
-    "@types/node": "^24.1.0",
+    "@types/node": "^24.3.0",
     "assert": "^2.1.0",
     "mocha": "^11.7.1",
-    "playwright-test": "^14.1.11",
+    "playwright-test": "^14.1.12",
     "type-fest": "^4.34.1",
-    "typescript": "5.8.3",
-    "viem": "^2.33.0"
+    "typescript": "5.9.2",
+    "viem": "^2.35.1"
   },
   "publishConfig": {
     "provenance": true

package/src/asn1.js

@@ -13,7 +13,6 @@ export const UNUSED_BIT_PAD = 0x00
 
 /**
  * @param {number} length
- * @returns {Uint8Array}
  */
 export const encodeDERLength = (length) => {
   if (length <= 127) {
@@ -31,9 +30,8 @@ export const encodeDERLength = (length) => {
 }
 
 /**
- * @param {Uint8Array} bytes
+ * @param {Uint8Array<ArrayBuffer>} bytes
  * @param {number} offset
- * @returns {{number: number, consumed: number}}
  */
 export const readDERLength = (bytes, offset = 0) => {
   if ((bytes[offset] & 0x80) === 0) {
@@ -58,10 +56,9 @@ export const readDERLength = (bytes, offset = 0) => {
 }
 
 /**
- * @param {Uint8Array} input
+ * @param {Uint8Array<ArrayBuffer>} input
  * @param {number} expectedTag
  * @param {number} position
- * @returns {number}
  */
 export const skip = (input, expectedTag, position) => {
   const parsed = into(input, expectedTag, position)
@@ -69,10 +66,9 @@ export const skip = (input, expectedTag, position) => {
 }
 
 /**
- * @param {Uint8Array} input
+ * @param {Uint8Array<ArrayBuffer>} input
  * @param {number} expectedTag
  * @param {number} offset
- * @returns {{ position: number, length: number }}
  */
 export const into = (input, expectedTag, offset) => {
   const actualTag = input[offset]
@@ -94,7 +90,7 @@ export const into = (input, expectedTag, offset) => {
 }
 
 /**
- * @param {Uint8Array} input
+ * @param {Uint8Array<ArrayBuffer>} input
  */
 export const encodeBitString = (input) => {
   // encode input length + 1 for unused bit pad
@@ -127,7 +123,7 @@ export const encodeBitString = (input) => {
 }
 
 /**
- * @param {Uint8Array} input
+ * @param {Uint8Array<ArrayBuffer>} input
  */
 export const encodeOctetString = (input) => {
   // encode input length
@@ -151,7 +147,7 @@ export const encodeOctetString = (input) => {
 }
 
 /**
- * @param {Uint8Array[]} sequence
+ * @param {Uint8Array<ArrayBuffer>[]} sequence
  */
 export const encodeSequence = (sequence) => {
   // calculate bytelength for all the parts
@@ -186,7 +182,7 @@ export const encodeSequence = (sequence) => {
 }
 
 /**
- * @param {Uint8Array} bytes
+ * @param {Uint8Array<ArrayBuffer>} bytes
  * @param {number} offset
  */
 export const readSequence = (bytes, offset = 0) => {
@@ -196,7 +192,7 @@ export const readSequence = (bytes, offset = 0) => {
 }
 
 /**
- * @param {Uint8Array} input
+ * @param {Uint8Array<ArrayBuffer>} input
  */
 export const encodeInt = (input) => {
   const extra = input.byteLength === 0 || input[0] & 0x80 ? 1 : 0
@@ -233,33 +229,28 @@ export const encodeInt = (input) => {
 }
 
 /**
- * @param {Uint8Array} bytes
+ * @param {Uint8Array<ArrayBuffer>} bytes
  * @param {number} offset
- * @returns {number}
  */
 
 export const enterSequence = (bytes, offset = 0) =>
   into(bytes, SEQUENCE_TAG, offset).position
 
 /**
- * @param {Uint8Array} bytes
+ * @param {Uint8Array<ArrayBuffer>} bytes
  * @param {number} offset
- * @returns {number}
  */
 export const skipSequence = (bytes, offset = 0) =>
   skip(bytes, SEQUENCE_TAG, offset)
 
 /**
- * @param {Uint8Array} bytes
+ * @param {Uint8Array<ArrayBuffer>} bytes
  * @param {number} offset
- * @returns {number}
  */
 export const skipInt = (bytes, offset = 0) => skip(bytes, INT_TAG, offset)
 
 /**
- * @param {Uint8Array} bytes
- * @param {number} offset
- * @returns {Uint8Array}
+ * @param {Uint8Array<ArrayBuffer>} bytes
  */
 export const readBitString = (bytes, offset = 0) => {
   const { position, length } = into(bytes, BITSTRING_TAG, offset)
@@ -279,9 +270,8 @@ export const readBitString = (bytes, offset = 0) => {
 }
 
 /**
- * @param {Uint8Array} bytes
+ * @param {Uint8Array<ArrayBuffer>} bytes
  * @param {number} byteOffset
- * @returns {Uint8Array}
  */
 export const readInt = (bytes, byteOffset = 0) => {
   const { position, length } = into(bytes, INT_TAG, byteOffset)
@@ -300,9 +290,8 @@ export const readInt = (bytes, byteOffset = 0) => {
 }
 
 /**
- * @param {Uint8Array} bytes
+ * @param {Uint8Array<ArrayBuffer>} bytes
  * @param {number} offset
- * @returns {Uint8Array}
  */
 export const readOctetString = (bytes, offset = 0) => {
   const { position, length } = into(bytes, OCTET_STRING_TAG, offset)
@@ -311,9 +300,9 @@ export const readOctetString = (bytes, offset = 0) => {
 }
 
 /**
- * @typedef {(bytes:Uint8Array, offset:number) => Uint8Array} Reader
+ * @typedef {(bytes:Uint8Array<ArrayBuffer>, offset:number) => Uint8Array<ArrayBuffer>} Reader
  * @param {[Reader, ...Reader[]]} readers
- * @param {Uint8Array} source
+ * @param {Uint8Array<ArrayBuffer>} source
  * @param {number} byteOffset
  */
 export const readSequenceWith = (readers, source, byteOffset = 0) => {

package/src/signers/ecdsa.js

@@ -192,7 +192,7 @@ export class ECDSASigner extends DID {
   /**
    * Sign a message
    *
-   * @param {Uint8Array} message
+   * @param {Uint8Array<ArrayBuffer>} message
    */
   async sign(message) {
     const buf = await webcrypto.subtle.sign(

package/src/signers/eddsa.js

@@ -1,5 +1,5 @@
 /* eslint-disable unicorn/numeric-separators-style */
-import { getPublicKeyAsync, signAsync, utils } from '@noble/ed25519'
+import { getPublicKeyAsync, keygenAsync, signAsync } from '@noble/ed25519'
 import { webcrypto } from 'iso-base/crypto'
 import { base64pad, base64url } from 'iso-base/rfc4648'
 import { tag, untag } from 'iso-base/varint'
@@ -7,7 +7,6 @@ import { DID } from 'iso-did'
 import { DIDKey } from 'iso-did/key'
 import { didKeyOrVerifiableDID } from '../utils.js'
 
-// @ts-ignore
 if (!globalThis.crypto) globalThis.crypto = webcrypto
 
 /**
@@ -60,10 +59,21 @@ export class EdDSASigner extends DID {
    * @param {Uint8Array} [bytes]
    */
   static async generate(bytes) {
-    const privateKey = bytes || utils.randomPrivateKey()
-    const publicKey = await getPublicKeyAsync(privateKey)
+    let privateKey
+    let publicKey
+    if (bytes) {
+      privateKey = bytes
+      publicKey = await getPublicKeyAsync(privateKey)
+    } else {
+      const key = await keygenAsync()
+      privateKey = key.secretKey
+      publicKey = key.publicKey
+    }
     return new EdDSASigner(
-      DIDKey.fromPublicKey('Ed25519', publicKey),
+      DIDKey.fromPublicKey(
+        'Ed25519',
+        /** @type {Uint8Array<ArrayBuffer>} */ (publicKey)
+      ),
       privateKey
     )
   }
@@ -79,7 +89,11 @@ export class EdDSASigner extends DID {
     const publicKey = await getPublicKeyAsync(privateKey)
 
     return new EdDSASigner(
-      didKeyOrVerifiableDID('Ed25519', publicKey, did),
+      didKeyOrVerifiableDID(
+        'Ed25519',
+        /** @type {Uint8Array<ArrayBuffer>} */ (publicKey),
+        did
+      ),
       privateKey
     )
   }
@@ -103,10 +117,12 @@ export class EdDSASigner extends DID {
   /**
    * Sign a message
    *
-   * @param {Uint8Array} message
+   * @param {Uint8Array<ArrayBuffer>} message
    */
   sign(message) {
-    return signAsync(message, this.#privateKey)
+    return /** @type {Promise<Uint8Array<ArrayBuffer>>} */ (
+      signAsync(message, this.#privateKey)
+    )
   }
 
   /**

package/src/signers/eip191.js

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

package/src/signers/es256k.js

@@ -1,6 +1,5 @@
 import { getPublicKey, signAsync, utils } from '@noble/secp256k1'
 import { base64pad, base64url } from 'iso-base/rfc4648'
-import { u8 } from 'iso-base/utils'
 import { tag, untag } from 'iso-base/varint'
 import { DID } from 'iso-did'
 import { DIDKey } from 'iso-did/key'
@@ -53,14 +52,17 @@ export class ES256KSigner extends DID {
   /**
    * Generate a new signer
    *
-   * @param {Uint8Array} [bytes]
+   * @param {Uint8Array<ArrayBuffer>} [bytes]
    */
   static generate(bytes) {
-    const privateKey = bytes || utils.randomPrivateKey()
+    const privateKey = bytes || utils.randomSecretKey()
     const publicKey = getPublicKey(privateKey)
 
     return new ES256KSigner(
-      DIDKey.fromPublicKey('secp256k1', publicKey),
+      DIDKey.fromPublicKey(
+        'secp256k1',
+        /** @type {Uint8Array<ArrayBuffer>} */ (publicKey)
+      ),
       privateKey
     )
   }
@@ -76,7 +78,11 @@ export class ES256KSigner extends DID {
     const publicKey = getPublicKey(privateKey)
 
     return new ES256KSigner(
-      didKeyOrVerifiableDID('secp256k1', publicKey, did),
+      didKeyOrVerifiableDID(
+        'secp256k1',
+        /** @type {Uint8Array<ArrayBuffer>} */ (publicKey),
+        did
+      ),
       privateKey
     )
   }
@@ -92,7 +98,11 @@ export class ES256KSigner extends DID {
     const publicKey = getPublicKey(privateKey)
 
     return new ES256KSigner(
-      didKeyOrVerifiableDID('secp256k1', publicKey, did),
+      didKeyOrVerifiableDID(
+        'secp256k1',
+        /** @type {Uint8Array<ArrayBuffer>} */ (publicKey),
+        did
+      ),
       privateKey
     )
   }
@@ -100,12 +110,11 @@ export class ES256KSigner extends DID {
   /**
    * Sign a message
    *
-   * @param {Uint8Array} message
+   * @param {Uint8Array<ArrayBuffer>} message
    */
   async sign(message) {
-    const hash = await globalThis.crypto.subtle.digest('SHA-256', message)
-    const sig = await signAsync(u8(hash), this.#privateKey)
-    return sig.toCompactRawBytes()
+    const sig = await signAsync(message, this.#privateKey)
+    return /** @type {Uint8Array<ArrayBuffer>} */ (sig)
   }
 
   /**

package/src/signers/rsa.js

@@ -132,7 +132,7 @@ export class RSASigner extends DID {
   /**
    * Sign a message
    *
-   * @param {Uint8Array} message
+   * @param {Uint8Array<ArrayBuffer>} message
    */
   async sign(message) {
     const buf = await webcrypto.subtle.sign(

package/src/spki.js

@@ -15,14 +15,14 @@ const SPKI_PARAMS_ENCODED = new Uint8Array([
 ])
 
 /**
- * @param {Uint8Array} key
+ * @param {Uint8Array<ArrayBuffer>} key
  */
 function encode(key) {
   return encodeSequence([SPKI_PARAMS_ENCODED, encodeBitString(key)])
 }
 
 /**
- * @param {Uint8Array} info
+ * @param {Uint8Array<ArrayBuffer>} 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) => Promise<Uint8Array>
+  sign: (message: Uint8Array<ArrayBuffer>) => Promise<Uint8Array<ArrayBuffer>>
 }
 
 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
-  message: Uint8Array
+  signature: Uint8Array<ArrayBuffer>
+  message: Uint8Array<ArrayBuffer>
   did: VerifiableDID
 }
 export type Verify = (input: VerifyInput) => Promise<boolean>

package/src/verifiers/ecdsa.js

@@ -1,7 +1,6 @@
-import { verify as secpVerify } from '@noble/secp256k1'
+import { verifyAsync as secpVerify } from '@noble/secp256k1'
 import { webcrypto } from 'iso-base/crypto'
 import { decompress, isCompressed } from 'iso-base/ec-compression'
-import { u8 } from 'iso-base/utils'
 import { createEcdsaParams } from '../signers/ecdsa.js'
 
 /**
@@ -45,9 +44,7 @@ async function es256kVerify({ signature, message, did }) {
     throw new Error('Invalid signature length')
   }
 
-  const hash = await globalThis.crypto.subtle.digest('SHA-256', message)
-
-  return secpVerify(signature, u8(hash), did.verifiableDid.publicKey)
+  return await secpVerify(signature, message, did.verifiableDid.publicKey)
 }
 
 /** @type {import('../types.js').Verifier<'ES256' | 'ES384' | 'ES512' | 'ES256K'>} */

package/src/verifiers/eip191.js

@@ -1,11 +1,8 @@
 import { keccak_256 } from '@noble/hashes/sha3'
-import { Signature } from '@noble/secp256k1'
+import { recoverPublicKeyAsync, Signature, verifyAsync } from '@noble/secp256k1'
 import { hex } from 'iso-base/rfc4648'
 import { utf8 } from 'iso-base/utf8'
 import { concat } from 'iso-base/utils'
-import { DIDPkh } from 'iso-did/pkh'
-import * as Address from 'ox/Address'
-import * as PublicKey from 'ox/PublicKey'
 import * as SignatureOx from 'ox/Signature'
 
 const PREFIX = '\x19Ethereum Signed Message:\n'
@@ -14,14 +11,13 @@ const PREFIX = '\x19Ethereum Signed Message:\n'
  * Convert a 0x signature to a Uint8Array
  *
  * @param {`0x${string}`} signature
- * @returns {Uint8Array}
  */
 export function hexToBytes(signature) {
   return hex.decode(signature.slice(2))
 }
 
 /**
- * @param { Uint8Array} data
+ * @param {Uint8Array<ArrayBuffer>} data
  */
 export function getSignPayload(data) {
   const prefixBytes = utf8.decode(`${PREFIX}${data.length}`)
@@ -29,16 +25,19 @@ export function getSignPayload(data) {
 }
 
 /** @type {import('../types.js').Verify} */
-export function verify({ signature, message, did }) {
-  const didPkh = DIDPkh.fromString(did.did)
-  const pubKey = Signature.fromCompact(signature.slice(0, 64))
+export async function verify({ signature, message }) {
+  const msgHash = getSignPayload(message)
+  const sigRecovered = Signature.fromBytes(signature.slice(0, 64))
     .addRecoveryBit(SignatureOx.vToYParity(signature[64]))
-    .recoverPublicKey(getSignPayload(message))
-    .toRawBytes(false)
+    .toBytes('recovered')
+  const pubKey = await recoverPublicKeyAsync(sigRecovered, msgHash, {
+    prehash: false,
+  })
 
-  const address = Address.fromPublicKey(PublicKey.fromBytes(pubKey))
-
-  return Promise.resolve(Address.isEqual(address, didPkh.address))
+  return await verifyAsync(sigRecovered, msgHash, pubKey, {
+    prehash: false,
+    format: 'recovered',
+  })
 }
 
 /** @type {import('../types').Verifier<'EIP191'>} */