iso-signatures 0.5.0 → 0.5.2

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 & 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":"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,qEAIpB;IAED;;OAEG;IACH,iBAEC;;CAKF;sBApHY,OAAO,aAAa,EAAE,OAAO,CAAC,MAAM,CAAC;oBAP9B,SAAS"}

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

@@ -1,6 +1,7 @@
 /**
  * @typedef {import('../types.js').ISigner<string>} ISigner
  * @typedef {import('ox').Provider.Provider} Provider
+ * @typedef {import('eventemitter3').EventEmitter} EventEmitter
  */
 /**
  * EIP191 signer
@@ -44,7 +45,7 @@ export class EIP191Signer extends DID implements ISigner {
     /** @type {import('../types.js').SignatureType} */
     signatureType: import("../types.js").SignatureType;
     provider: {
-        request: Provider.RequestFn<{
+        request: import("ox/Provider").RequestFn<{
             Request: {
                 method: "eth_accounts";
                 params?: undefined;
@@ -248,6 +249,12 @@ export class EIP191Signer extends DID implements ISigner {
                 params: [serializedTransaction: import("ox/Hex").Hex];
             };
             ReturnType: import("ox/Hex").Hex;
+        } | {
+            Request: {
+                method: "eth_sendRawTransactionSync";
+                params: [serializedTransaction: import("ox/Hex").Hex] | [serializedTransaction: import("ox/Hex").Hex, timeout: number];
+            };
+            ReturnType: import("ox/TransactionReceipt").Rpc;
         } | {
             Request: {
                 method: "eth_sendTransaction";
@@ -259,7 +266,7 @@ export class EIP191Signer extends DID implements ISigner {
                 method: "eth_simulateV1";
                 params: [{
                     blockStateCalls: readonly {
-                        blockOverrides?: import("ox/BlockOverrides").Rpc | undefined;
+                        blockOverrides?: import("viem").RpcBlockOverrides | undefined;
                         calls?: readonly import("ox/TransactionRequest").Rpc[] | undefined;
                         stateOverrides?: import("ox/StateOverrides").Rpc | undefined;
                     }[];
@@ -311,6 +318,12 @@ export class EIP191Signer extends DID implements ISigner {
                 params: [serializedTransaction: import("ox/Hex").Hex];
             };
             ReturnType: import("ox/Hex").Hex;
+        } | {
+            Request: {
+                method: "eth_sendRawTransactionSync";
+                params: [serializedTransaction: import("ox/Hex").Hex] | [serializedTransaction: import("ox/Hex").Hex, timeout: number];
+            };
+            ReturnType: import("ox/TransactionReceipt").Rpc;
         } | {
             Request: {
                 method: "eth_sendTransaction";
@@ -525,8 +538,94 @@ export class EIP191Signer extends DID implements ISigner {
             };
             ReturnType: boolean;
         }>;
-        on: Provider.EventListenerFn;
-        removeListener: Provider.EventListenerFn;
+        eventNames?: (() => ("accountsChanged" | "chainChanged" | "connect" | "disconnect" | "message")[]) | undefined;
+        listeners?: (<T extends "accountsChanged" | "chainChanged" | "connect" | "disconnect" | "message">(event: T) => ((...args: import("eventemitter3").EventEmitter.ArgumentMap<{
+            accountsChanged: (accounts: readonly import("ox/Address").Address[]) => void;
+            chainChanged: (chainId: string) => void;
+            connect: (connectInfo: import("ox/Provider").ConnectInfo) => void;
+            disconnect: (error: import("ox/Provider").ProviderRpcError) => void;
+            message: (message: import("ox/Provider").Message) => void;
+        }>[Extract<T, "accountsChanged" | "chainChanged" | "connect" | "disconnect" | "message">]) => void)[]) | undefined;
+        listenerCount?: ((event: "accountsChanged" | "chainChanged" | "connect" | "disconnect" | "message") => number) | undefined;
+        emit?: (<T extends "accountsChanged" | "chainChanged" | "connect" | "disconnect" | "message">(event: T, ...args: import("eventemitter3").EventEmitter.ArgumentMap<{
+            accountsChanged: (accounts: readonly import("ox/Address").Address[]) => void;
+            chainChanged: (chainId: string) => void;
+            connect: (connectInfo: import("ox/Provider").ConnectInfo) => void;
+            disconnect: (error: import("ox/Provider").ProviderRpcError) => void;
+            message: (message: import("ox/Provider").Message) => void;
+        }>[Extract<T, "accountsChanged" | "chainChanged" | "connect" | "disconnect" | "message">]) => boolean) | undefined;
+        on?: (<T extends "accountsChanged" | "chainChanged" | "connect" | "disconnect" | "message">(event: T, fn: (...args: import("eventemitter3").EventEmitter.ArgumentMap<{
+            accountsChanged: (accounts: readonly import("ox/Address").Address[]) => void;
+            chainChanged: (chainId: string) => void;
+            connect: (connectInfo: import("ox/Provider").ConnectInfo) => void;
+            disconnect: (error: import("ox/Provider").ProviderRpcError) => void;
+            message: (message: import("ox/Provider").Message) => void;
+        }>[Extract<T, "accountsChanged" | "chainChanged" | "connect" | "disconnect" | "message">]) => void, context?: any) => import("eventemitter3").EventEmitter<{
+            accountsChanged: (accounts: readonly import("ox/Address").Address[]) => void;
+            chainChanged: (chainId: string) => void;
+            connect: (connectInfo: import("ox/Provider").ConnectInfo) => void;
+            disconnect: (error: import("ox/Provider").ProviderRpcError) => void;
+            message: (message: import("ox/Provider").Message) => void;
+        }, any>) | undefined;
+        addListener?: (<T extends "accountsChanged" | "chainChanged" | "connect" | "disconnect" | "message">(event: T, fn: (...args: import("eventemitter3").EventEmitter.ArgumentMap<{
+            accountsChanged: (accounts: readonly import("ox/Address").Address[]) => void;
+            chainChanged: (chainId: string) => void;
+            connect: (connectInfo: import("ox/Provider").ConnectInfo) => void;
+            disconnect: (error: import("ox/Provider").ProviderRpcError) => void;
+            message: (message: import("ox/Provider").Message) => void;
+        }>[Extract<T, "accountsChanged" | "chainChanged" | "connect" | "disconnect" | "message">]) => void, context?: any) => import("eventemitter3").EventEmitter<{
+            accountsChanged: (accounts: readonly import("ox/Address").Address[]) => void;
+            chainChanged: (chainId: string) => void;
+            connect: (connectInfo: import("ox/Provider").ConnectInfo) => void;
+            disconnect: (error: import("ox/Provider").ProviderRpcError) => void;
+            message: (message: import("ox/Provider").Message) => void;
+        }, any>) | undefined;
+        once?: (<T extends "accountsChanged" | "chainChanged" | "connect" | "disconnect" | "message">(event: T, fn: (...args: import("eventemitter3").EventEmitter.ArgumentMap<{
+            accountsChanged: (accounts: readonly import("ox/Address").Address[]) => void;
+            chainChanged: (chainId: string) => void;
+            connect: (connectInfo: import("ox/Provider").ConnectInfo) => void;
+            disconnect: (error: import("ox/Provider").ProviderRpcError) => void;
+            message: (message: import("ox/Provider").Message) => void;
+        }>[Extract<T, "accountsChanged" | "chainChanged" | "connect" | "disconnect" | "message">]) => void, context?: any) => import("eventemitter3").EventEmitter<{
+            accountsChanged: (accounts: readonly import("ox/Address").Address[]) => void;
+            chainChanged: (chainId: string) => void;
+            connect: (connectInfo: import("ox/Provider").ConnectInfo) => void;
+            disconnect: (error: import("ox/Provider").ProviderRpcError) => void;
+            message: (message: import("ox/Provider").Message) => void;
+        }, any>) | undefined;
+        removeListener?: (<T extends "accountsChanged" | "chainChanged" | "connect" | "disconnect" | "message">(event: T, fn?: ((...args: import("eventemitter3").EventEmitter.ArgumentMap<{
+            accountsChanged: (accounts: readonly import("ox/Address").Address[]) => void;
+            chainChanged: (chainId: string) => void;
+            connect: (connectInfo: import("ox/Provider").ConnectInfo) => void;
+            disconnect: (error: import("ox/Provider").ProviderRpcError) => void;
+            message: (message: import("ox/Provider").Message) => void;
+        }>[Extract<T, "accountsChanged" | "chainChanged" | "connect" | "disconnect" | "message">]) => void) | undefined, context?: any, once?: boolean) => import("eventemitter3").EventEmitter<{
+            accountsChanged: (accounts: readonly import("ox/Address").Address[]) => void;
+            chainChanged: (chainId: string) => void;
+            connect: (connectInfo: import("ox/Provider").ConnectInfo) => void;
+            disconnect: (error: import("ox/Provider").ProviderRpcError) => void;
+            message: (message: import("ox/Provider").Message) => void;
+        }, any>) | undefined;
+        off?: (<T extends "accountsChanged" | "chainChanged" | "connect" | "disconnect" | "message">(event: T, fn?: ((...args: import("eventemitter3").EventEmitter.ArgumentMap<{
+            accountsChanged: (accounts: readonly import("ox/Address").Address[]) => void;
+            chainChanged: (chainId: string) => void;
+            connect: (connectInfo: import("ox/Provider").ConnectInfo) => void;
+            disconnect: (error: import("ox/Provider").ProviderRpcError) => void;
+            message: (message: import("ox/Provider").Message) => void;
+        }>[Extract<T, "accountsChanged" | "chainChanged" | "connect" | "disconnect" | "message">]) => void) | undefined, context?: any, once?: boolean) => import("eventemitter3").EventEmitter<{
+            accountsChanged: (accounts: readonly import("ox/Address").Address[]) => void;
+            chainChanged: (chainId: string) => void;
+            connect: (connectInfo: import("ox/Provider").ConnectInfo) => void;
+            disconnect: (error: import("ox/Provider").ProviderRpcError) => void;
+            message: (message: import("ox/Provider").Message) => void;
+        }, any>) | undefined;
+        removeAllListeners?: ((event?: "accountsChanged" | "chainChanged" | "connect" | "disconnect" | "message" | undefined) => import("eventemitter3").EventEmitter<{
+            accountsChanged: (accounts: readonly import("ox/Address").Address[]) => void;
+            chainChanged: (chainId: string) => void;
+            connect: (connectInfo: import("ox/Provider").ConnectInfo) => void;
+            disconnect: (error: import("ox/Provider").ProviderRpcError) => void;
+            message: (message: import("ox/Provider").Message) => void;
+        }, any>) | undefined;
     };
     address: `0x${string}`;
     chainId: number | `0x${string}`;
@@ -534,9 +633,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
      */
@@ -544,6 +643,6 @@ export class EIP191Signer extends DID implements ISigner {
 }
 export type ISigner = import("../types.js").ISigner<string>;
 export type Provider = import("ox").Provider.Provider;
+export type EventEmitter = import("eventemitter3").EventEmitter;
 import { DID } from 'iso-did';
-import { Provider } from 'ox';
 //# sourceMappingURL=eip191.d.ts.map

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":"AAIA;;;;GAIG;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;;;;sBAW0B,CAAC;;;;;;sBAOJ,CAAC;;;;;;sBAUpB,CAAL;;;;;;;;;;;;sBAqCwQ,CAAC;;;;;;sBAAmP,CAAC;;;;;;;;;;;;;;;;;;sBAA6jE,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAAqxP,CAAC;;;;;;sBAAkT,CAAC;;;;;;;;;;;;sBAAovB,CAAC;;;;;;sBAAuQ,CAAC;;;;;;sBAAwW,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;sCAAs0C,CAAC;6BAA2D,CAAC;sCAAmF,CAAC;;0CAA6F,CAAC;kCAAqD,CAAC;8BAAiD,CAAC;;;;qBAAkM,CAAC;yBAA8B,CAAC;4BAAwB,CAAC;;;;wBAAiI,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAnE9+b,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAmE4gD,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAjEh5R;IACxB,uBAAsB;IACtB,gCAAsB;IACtB,kBAA0B;IAsC5B;;;;OAIG;IACH,cAFW,UAAU,wCAQpB;IAED;;OAEG;IACH,iBAEC;CAKF;sBAzFY,OAAO,aAAa,EAAE,OAAO,CAAC,MAAM,CAAC;uBACrC,OAAO,IAAI,EAAE,QAAQ,CAAC,QAAQ;2BAC9B,OAAO,eAAe,EAAE,YAAY;oBAN7B,SAAS"}

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 & 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":"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,uEAKpB;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> & Uint8Array<ArrayBuffer>;
 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":"AAYA;;;;GAIG;AACH,sCAFW,KAAK,MAAM,EAAE,+BAIvB;AAED;;GAEG;AACH,qCAFW,UAAU,yDAKpB;;AAyBD,oDAAoD;AACpD,uBADW,OAAO,UAAU,EAAE,QAAQ,CAAC,QAAQ,CAAC,CAG/C"}

package/license

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) Hugo Dias <hugomrdias@gmail.com> (hugodias.me)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "iso-signatures",
   "type": "module",
-  "version": "0.5.0",
+  "version": "0.5.2",
   "description": "Signatures tooling.",
   "author": "Hugo Dias <hugomrdias@gmail.com> (hugodias.me)",
   "license": "MIT",
@@ -81,23 +81,24 @@
     "dist/src/**/*.d.ts.map"
   ],
   "dependencies": {
-    "@noble/ed25519": "^3.0.0",
+    "@noble/ed25519": "^3.0.1",
     "@noble/hashes": "^2.0.0",
     "@noble/secp256k1": "^3.0.0",
-    "ox": "^0.9.1",
-    "iso-base": "^4.2.0",
-    "iso-did": "^2.1.0"
+    "eventemitter3": "5.0.1",
+    "iso-base": "^4.4.0",
+    "iso-did": "^2.1.1",
+    "ox": "^0.14.30"
   },
   "devDependencies": {
     "@types/assert": "^1.5.11",
     "@types/mocha": "^10.0.10",
-    "@types/node": "^24.3.0",
+    "@types/node": "^26.1.1",
     "assert": "^2.1.0",
-    "mocha": "^11.7.1",
-    "playwright-test": "^14.1.12",
-    "type-fest": "^4.34.1",
-    "typescript": "5.9.2",
-    "viem": "^2.35.1"
+    "mocha": "^11.7.5",
+    "playwright-test": "^14.1.13",
+    "type-fest": "^5.8.0",
+    "typescript": "^6.0.3",
+    "viem": "^2.54.6"
   },
   "publishConfig": {
     "provenance": true
@@ -110,7 +111,8 @@
       "@types/*",
       "assert",
       "type-fest",
-      "mocha"
+      "mocha",
+      "eventemitter3"
     ]
   },
   "scripts": {

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

@@ -1,11 +1,11 @@
 import { hex } from 'iso-base/rfc4648'
 import { DID } from 'iso-did'
 import { DIDPkh } from 'iso-did/pkh'
-import { Provider } from 'ox'
 
 /**
  * @typedef {import('../types.js').ISigner<string>} ISigner
  * @typedef {import('ox').Provider.Provider} Provider
+ * @typedef {import('eventemitter3').EventEmitter} EventEmitter
  */
 
 /**
@@ -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,8 +1,11 @@
-import { keccak_256 } from '@noble/hashes/sha3'
-import { recoverPublicKeyAsync, Signature, verifyAsync } from '@noble/secp256k1'
+import { keccak_256 } from '@noble/hashes/sha3.js'
+import { Point, recoverPublicKeyAsync, Signature } 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'
@@ -17,7 +20,7 @@ export function hexToBytes(signature) {
 }
 
 /**
- * @param {Uint8Array<ArrayBuffer>} data
+ * @param {Uint8Array} data
  */
 export function getSignPayload(data) {
   const prefixBytes = utf8.decode(`${PREFIX}${data.length}`)
@@ -25,19 +28,26 @@ export function getSignPayload(data) {
 }
 
 /** @type {import('../types.js').Verify} */
-export async function verify({ signature, message }) {
-  const msgHash = getSignPayload(message)
+export async function verify({ signature, message, did }) {
+  if (signature.length !== 65) {
+    throw new Error('Invalid signature length')
+  }
+
+  const didPkh = DIDPkh.fromString(did.did)
   const sigRecovered = Signature.fromBytes(signature.slice(0, 64))
     .addRecoveryBit(SignatureOx.vToYParity(signature[64]))
     .toBytes('recovered')
-  const pubKey = await recoverPublicKeyAsync(sigRecovered, msgHash, {
-    prehash: false,
-  })
+  const pubKey = await recoverPublicKeyAsync(
+    sigRecovered,
+    getSignPayload(message),
+    { prehash: false }
+  )
+  // noble returns a compressed key, address derivation needs it uncompressed
+  const address = Address.fromPublicKey(
+    PublicKey.fromBytes(Point.fromBytes(pubKey).toBytes(false))
+  )
 
-  return await verifyAsync(sigRecovered, msgHash, pubKey, {
-    prehash: false,
-    format: 'recovered',
-  })
+  return Address.isEqual(address, didPkh.address)
 }
 
 /** @type {import('../types').Verifier<'EIP191'>} */

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)
   )
 }