iso-signatures 0.5.1 → 0.5.2

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

@@ -42,7 +42,7 @@ export class EdDSASigner extends DID implements ISigner {
      *
      * @param {Uint8Array} message
      */
-    sign(message: Uint8Array): Promise<import("@noble/ed25519").Bytes>;
+    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,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"}
+{"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}`;
@@ -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;;;;;;;;;;;;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":"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

@@ -43,7 +43,7 @@ export class ES256KSigner extends DID implements ISigner {
      *
      * @param {Uint8Array} message
      */
-    sign(message: Uint8Array): Promise<import("@noble/secp256k1").Bytes>;
+    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,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"}
+{"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/verifiers/eip191.d.ts

@@ -7,7 +7,7 @@ export function hexToBytes(signature: `0x${string}`): Uint8Array<ArrayBufferLike
 /**
  * @param {Uint8Array} data
  */
-export function getSignPayload(data: Uint8Array): 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,+BAIvB;AAED;;GAEG;AACH,qCAFW,UAAU,+BAKpB;;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.1",
+  "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.6",
-    "iso-base": "^4.2.1",
-    "iso-did": "^2.1.1"
+    "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.5.2",
+    "@types/node": "^26.1.1",
     "assert": "^2.1.0",
-    "mocha": "^11.7.2",
-    "playwright-test": "^14.1.12",
-    "type-fest": "^5.0.1",
-    "typescript": "5.9.2",
-    "viem": "^2.37.6"
+    "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/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
  */
 
 /**

package/src/verifiers/eip191.js

@@ -1,8 +1,11 @@
 import { keccak_256 } from '@noble/hashes/sha3.js'
-import { recoverPublicKeyAsync, Signature, verifyAsync } from '@noble/secp256k1'
+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'
@@ -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'>} */