iso-signatures 0.5.1 → 0.6.0

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

@@ -1,3 +1,19 @@
+/**
+ * Check if a raw `r‖s` ECDSA signature has a high S value (`s > n/2`)
+ *
+ * Signatures with the wrong length for the curve are reported as high S.
+ *
+ * @param {Curves} curve
+ * @param {Uint8Array} signature
+ */
+export function isHighS(curve: Curves, signature: Uint8Array): boolean;
+/**
+ * Normalize a raw `r‖s` ECDSA signature to low S (`s <= n/2`)
+ *
+ * @param {Curves} curve
+ * @param {Uint8Array} signature
+ */
+export function normalizeS(curve: Curves, signature: Uint8Array): Uint8Array<ArrayBufferLike>;
 /**
  * Create web crypto params for ECDSA.
  *
@@ -46,6 +62,9 @@ export class ECDSASigner extends DID implements ISigner {
     /**
      * Sign a message
      *
+     * Signatures are normalized to low S (`s <= n/2`) so each message has a
+     * single signature encoding per signing operation.
+     *
      * @param {Uint8Array} message
      */
     sign(message: Uint8Array): Promise<Uint8Array<ArrayBufferLike>>;

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,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"}
+{"version":3,"file":"ecdsa.d.ts","sourceRoot":"","sources":["../../../src/signers/ecdsa.js"],"names":[],"mappings":"AA6DA;;;;;;;GAOG;AACH,+BAHW,MAAM,aACN,UAAU,WASpB;AAED;;;;;GAKG;AACH,kCAHW,MAAM,aACN,UAAU,+BAcpB;AAED;;;;;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;;;;;;;OAOG;IACH,cAFW,UAAU,wCAUpB;IAED;;;;OAIG;IACH,UAFa,aAAa,CAIzB;;CAKF;sBAlRY,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

@@ -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<Uint8Array<ArrayBufferLike> & 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,kEAIpB;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;
@@ -158,6 +159,12 @@ export class EIP191Signer extends DID implements ISigner {
                 params: [address: import("ox/Address").Address, storageKeys: import("ox/Hex").Hex[], block: import("ox/Block").Number<import("ox/Hex").Hex> | import("ox/Block").Tag | import("ox/Block").Hash | import("ox/Block").Identifier];
             };
             ReturnType: import("ox/AccountProof").Rpc;
+        } | {
+            Request: {
+                method: "eth_getRawTransactionByHash";
+                params: [hash: import("ox/Hex").Hex];
+            };
+            ReturnType: import("ox/Hex").Hex | null;
         } | {
             Request: {
                 method: "eth_getStorageAt";
@@ -248,6 +255,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";
@@ -311,6 +324,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 +544,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 +649,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAA2lQ,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;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAnEpzc,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<Uint8Array<ArrayBufferLike> & 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,kEAKpB;IAED;;OAEG;IACH,iBAEC;;CAKF;sBA9GY,OAAO,aAAa,EAAE,OAAO,CAAC,MAAM,CAAC;oBAL9B,SAAS"}

package/dist/src/types.d.ts

@@ -11,6 +11,16 @@ export interface VerifyInput {
     signature: Uint8Array;
     message: Uint8Array;
     did: VerifiableDID;
+    /**
+     * Only accept the canonical signature encoding. ECDSA (P-256/384/521) and
+     * EIP-191 signatures with a high S value (`s > n/2`) are rejected, and
+     * EIP-191 signatures must use 27/28 as the recovery byte.
+     *
+     * Other signature types ignore this option.
+     *
+     * @default false
+     */
+    strict?: boolean;
 }
 export type Verify = (input: VerifyInput) => Promise<boolean>;
 export type Verifier<T extends SignatureType> = Record<T, Verify>;
@@ -27,5 +37,15 @@ export interface IResolver {
 }
 export interface ResolverOptions {
     cache?: Cache | boolean | undefined;
+    /**
+     * Default `strict` value for verify calls that don't set it.
+     *
+     * Only enable this when you control all signers: other implementations
+     * produce high S ECDSA signatures and 0/1 EIP-191 recovery bytes.
+     *
+     * @see {@link VerifyInput.strict}
+     * @default false
+     */
+    strict?: boolean;
 }
 //# sourceMappingURL=types.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,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,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;IAClB;;;;;;;;OAQG;IACH,MAAM,CAAC,EAAE,OAAO,CAAA;CACjB;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;IACnC;;;;;;;;OAQG;IACH,MAAM,CAAC,EAAE,OAAO,CAAA;CACjB"}

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

@@ -1,10 +1,10 @@
 /**
  *
  * @param {'ES256' | 'ES384' | 'ES512' | 'ES256K'} type
- * @param {import('../types.js').VerifyInput} param1
+ * @param {import('../types.js').VerifyInput} input
  * @returns
  */
-export function verify(type: "ES256" | "ES384" | "ES512" | "ES256K", { signature, message, did }: import("../types.js").VerifyInput): Promise<boolean>;
+export function verify(type: "ES256" | "ES384" | "ES512" | "ES256K", input: import("../types.js").VerifyInput): Promise<boolean>;
 /** @type {import('../types.js').Verifier<'ES256' | 'ES384' | 'ES512' | 'ES256K'>} */
 export const verifier: import("../types.js").Verifier<"ES256" | "ES384" | "ES512" | "ES256K">;
 //# sourceMappingURL=ecdsa.d.ts.map

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

@@ -1 +1 @@
-{"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"}
+{"version":3,"file":"ecdsa.d.ts","sourceRoot":"","sources":["../../../src/verifiers/ecdsa.js"],"names":[],"mappings":"AA6DA;;;;;GAKG;AACH,6BAJW,OAAO,GAAG,OAAO,GAAG,OAAO,GAAG,QAAQ,SACtC,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

@@ -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":"AAWA;;;;GAIG;AACH,sCAFW,KAAK,MAAM,EAAE,+BAIvB;AAED;;GAEG;AACH,qCAFW,UAAU,yDAKpB;;AAoCD,oDAAoD;AACpD,uBADW,OAAO,UAAU,EAAE,QAAQ,CAAC,QAAQ,CAAC,CAG/C"}

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

@@ -12,6 +12,7 @@ export class Resolver implements IResolver {
     constructor(registry?: import("../types").VerifierRegistry<import("../types").SignatureType>, options?: import("../types").ResolverOptions);
     registry: Partial<import("../types").Verifier<import("../types").SignatureType>>;
     cache: import("../types").Cache;
+    strict: boolean;
     verify(input: import("../types").ResolverVerifyInput): Promise<boolean>;
 }
 export type IResolver = import("../types").IResolver;

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

@@ -1 +1 @@
-{"version":3,"file":"resolver.d.ts","sourceRoot":"","sources":["../../../src/verifiers/resolver.js"],"names":[],"mappings":"AAsCA;;;;GAIG;AACH,iCAFgB,SAAS;IAGvB;;;;OAIG;IACH,uBAHW,OAAO,UAAU,EAAE,gBAAgB,CAAC,OAAO,UAAU,EAAE,aAAa,CAAC,YACrE,OAAO,UAAU,EAAE,eAAe,EAM5C;IAHC,iFAAwB;IACxB,gCACmE;;CAYtE;wBA/DY,OAAO,UAAU,EAAE,SAAS"}
+{"version":3,"file":"resolver.d.ts","sourceRoot":"","sources":["../../../src/verifiers/resolver.js"],"names":[],"mappings":"AAsCA;;;;GAIG;AACH,iCAFgB,SAAS;IAGvB;;;;OAIG;IACH,uBAHW,OAAO,UAAU,EAAE,gBAAgB,CAAC,OAAO,UAAU,EAAE,aAAa,CAAC,YACrE,OAAO,UAAU,EAAE,eAAe,EAO5C;IAJC,iFAAwB;IACxB,gCACmE;IACnE,gBAAqC;;CAYxC;wBAhEY,OAAO,UAAU,EAAE,SAAS"}

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.6.0",
   "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/hashes": "^2.0.0",
-    "@noble/secp256k1": "^3.0.0",
-    "ox": "^0.9.6",
-    "iso-base": "^4.2.1",
-    "iso-did": "^2.1.1"
+    "@noble/ed25519": "^3.2.0",
+    "@noble/hashes": "^2.4.0",
+    "@noble/secp256k1": "^3.2.0",
+    "eventemitter3": "5.0.1",
+    "iso-base": "^4.4.0",
+    "iso-did": "^3.0.0",
+    "ox": "^0.14.49"
   },
   "devDependencies": {
     "@types/assert": "^1.5.11",
     "@types/mocha": "^10.0.10",
-    "@types/node": "^24.5.2",
+    "@types/node": "^26.6.2",
     "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": "^12.0.2",
+    "playwright-test": "^15.0.1",
+    "type-fest": "^5.10.0",
+    "typescript": "^6.0.3",
+    "viem": "~2.56.9"
   },
   "publishConfig": {
     "provenance": true
@@ -110,7 +111,8 @@
       "@types/*",
       "assert",
       "type-fest",
-      "mocha"
+      "mocha",
+      "eventemitter3"
     ]
   },
   "scripts": {

package/readme.md

@@ -52,6 +52,31 @@ const verified = await resolver.verify({
 })
 ```
 
+### Strict verification
+
+`ECDSASigner` always emits low S signatures (`s <= n/2`). Verifiers accept both
+low and high S by default, since other implementations produce high S
+signatures. If you control all your signers, enable `strict` to only accept the
+canonical encoding: ECDSA (P-256/384/521) and EIP-191 signatures with high S are
+rejected, and EIP-191 signatures must use 27/28 as the recovery byte.
+
+```js
+import * as ECDSA from 'iso-signatures/verifiers/ecdsa'
+import * as EIP191 from 'iso-signatures/verifiers/eip191'
+import { Resolver } from 'iso-signatures/verifiers/resolver'
+
+const resolver = new Resolver(
+  {
+    ...ECDSA.verifier,
+    ...EIP191.verifier,
+  },
+  { strict: true }
+)
+
+// or per call
+await ECDSA.verify('ES256', { signature, message, did, strict: true })
+```
+
 ## Docs
 
 Check <https://hugomrdias.github.io/iso-repo/modules/iso_signatures.html>

package/src/signers/ecdsa.js

@@ -1,4 +1,5 @@
 import { webcrypto } from 'iso-base/crypto'
+import { hex } from 'iso-base/rfc4648'
 import { u8 } from 'iso-base/utils'
 import { DID } from 'iso-did'
 import { DIDKey } from 'iso-did/key'
@@ -38,6 +39,63 @@ function curveToSignatureType(type) {
   }
 }
 
+/**
+ * Curve orders (n) and signature component sizes in bytes
+ *
+ * @type {Record<Curves, {n: bigint, size: number}>}
+ */
+const CURVES = {
+  'P-256': {
+    n: 0xffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551n,
+    size: 32,
+  },
+  'P-384': {
+    n: 0xffffffffffffffffffffffffffffffffffffffffffffffffc7634d81f4372ddf581a0db248b0a77aecec196accc52973n,
+    size: 48,
+  },
+  'P-521': {
+    n: 0x01fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffa51868783bf2f966b7fcc0148f709a5d03bb5c9b8899c47aebb6fb71e91386409n,
+    size: 66,
+  },
+}
+
+/**
+ * Check if a raw `r‖s` ECDSA signature has a high S value (`s > n/2`)
+ *
+ * Signatures with the wrong length for the curve are reported as high S.
+ *
+ * @param {Curves} curve
+ * @param {Uint8Array} signature
+ */
+export function isHighS(curve, signature) {
+  const { n, size } = CURVES[curve]
+  if (signature.length !== size * 2) {
+    return true
+  }
+  const s = BigInt(`0x${hex.encode(signature.subarray(size))}`)
+  return s > n >> 1n
+}
+
+/**
+ * Normalize a raw `r‖s` ECDSA signature to low S (`s <= n/2`)
+ *
+ * @param {Curves} curve
+ * @param {Uint8Array} signature
+ */
+export function normalizeS(curve, signature) {
+  const { n, size } = CURVES[curve]
+  if (signature.length !== size * 2) {
+    throw new Error('Invalid signature length')
+  }
+  const s = BigInt(`0x${hex.encode(signature.subarray(size))}`)
+  if (s <= n >> 1n) {
+    return signature
+  }
+  const out = new Uint8Array(signature)
+  out.set(hex.decode((n - s).toString(16).padStart(size * 2, '0')), size)
+  return out
+}
+
 /**
  * Create web crypto params for ECDSA.
  *
@@ -195,6 +253,9 @@ export class ECDSASigner extends DID {
   /**
    * Sign a message
    *
+   * Signatures are normalized to low S (`s <= n/2`) so each message has a
+   * single signature encoding per signing operation.
+   *
    * @param {Uint8Array} message
    */
   async sign(message) {
@@ -204,7 +265,7 @@ export class ECDSASigner extends DID {
       /** @type {BufferSource} */ (message)
     )
 
-    return u8(buf)
+    return normalizeS(this.curve, u8(buf))
   }
 
   /**

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/types.ts

@@ -24,6 +24,16 @@ export interface VerifyInput {
   signature: Uint8Array
   message: Uint8Array
   did: VerifiableDID
+  /**
+   * Only accept the canonical signature encoding. ECDSA (P-256/384/521) and
+   * EIP-191 signatures with a high S value (`s > n/2`) are rejected, and
+   * EIP-191 signatures must use 27/28 as the recovery byte.
+   *
+   * Other signature types ignore this option.
+   *
+   * @default false
+   */
+  strict?: boolean
 }
 export type Verify = (input: VerifyInput) => Promise<boolean>
 
@@ -45,4 +55,14 @@ export interface IResolver {
 
 export interface ResolverOptions {
   cache?: Cache | boolean | undefined
+  /**
+   * Default `strict` value for verify calls that don't set it.
+   *
+   * Only enable this when you control all signers: other implementations
+   * produce high S ECDSA signatures and 0/1 EIP-191 recovery bytes.
+   *
+   * @see {@link VerifyInput.strict}
+   * @default false
+   */
+  strict?: boolean
 }

package/src/verifiers/ecdsa.js

@@ -1,7 +1,7 @@
 import { verifyAsync as secpVerify } from '@noble/secp256k1'
 import { webcrypto } from 'iso-base/crypto'
 import { decompress, isCompressed } from 'iso-base/ec-compression'
-import { createEcdsaParams } from '../signers/ecdsa.js'
+import { createEcdsaParams, isHighS } from '../signers/ecdsa.js'
 
 /**
  *
@@ -11,7 +11,11 @@ function createVerifier(curve) {
   const params = createEcdsaParams(curve)
 
   /** @type {import('../types.js').Verify} */
-  async function fn({ signature, message, did }) {
+  async function fn({ signature, message, did, strict }) {
+    if (strict && isHighS(curve, signature)) {
+      return false
+    }
+
     let publicKey = did.verifiableDid.publicKey
     if (isCompressed(publicKey)) {
       publicKey = decompress(publicKey, params.namedCurve)
@@ -58,9 +62,9 @@ export const verifier = {
 /**
  *
  * @param {'ES256' | 'ES384' | 'ES512' | 'ES256K'} type
- * @param {import('../types.js').VerifyInput} param1
+ * @param {import('../types.js').VerifyInput} input
  * @returns
  */
-export async function verify(type, { signature, message, did }) {
-  return await verifier[type]({ signature, message, did })
+export async function verify(type, input) {
+  return await verifier[type](input)
 }

package/src/verifiers/eip191.js

@@ -1,9 +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 * as SignatureOx from 'ox/Signature'
+import { DIDPkh } from 'iso-did/pkh'
+import * as Address from 'ox/Address'
+import * as PublicKey from 'ox/PublicKey'
 
 const PREFIX = '\x19Ethereum Signed Message:\n'
 
@@ -25,19 +27,37 @@ export function getSignPayload(data) {
 }
 
 /** @type {import('../types.js').Verify} */
-export async function verify({ signature, message }) {
-  const msgHash = getSignPayload(message)
-  const sigRecovered = Signature.fromBytes(signature.slice(0, 64))
-    .addRecoveryBit(SignatureOx.vToYParity(signature[64]))
-    .toBytes('recovered')
-  const pubKey = await recoverPublicKeyAsync(sigRecovered, msgHash, {
-    prehash: false,
-  })
-
-  return await verifyAsync(sigRecovered, msgHash, pubKey, {
-    prehash: false,
-    format: 'recovered',
-  })
+export async function verify({ signature, message, did, strict }) {
+  if (signature.length !== 65) {
+    throw new Error('Invalid signature length')
+  }
+
+  // personal_sign signatures carry v as 27/28, or 0/1 from some signers.
+  // EIP-155 values (v >= 35) only apply to transactions.
+  const v = signature[64]
+  if (v !== 0 && v !== 1 && v !== 27 && v !== 28) {
+    throw new Error('Invalid signature recovery byte')
+  }
+
+  const didPkh = DIDPkh.fromString(did.did)
+  const sig = Signature.fromBytes(signature.slice(0, 64))
+  // strict mode only accepts the canonical encoding: low S and v as 27/28
+  if (strict && (sig.hasHighS() || (v !== 27 && v !== 28))) {
+    return false
+  }
+
+  const sigRecovered = sig.addRecoveryBit(v % 27).toBytes('recovered')
+  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 Address.isEqual(address, didPkh.address)
 }
 
 /** @type {import('../types').Verifier<'EIP191'>} */

package/src/verifiers/resolver.js

@@ -23,7 +23,7 @@ function memoryCache() {
 
   /** @type {import('../types').Cache} */
   async function fn(input, verify) {
-    const key = `${input.did.verifiableDid.toString()}:${hex.encode(input.signature)}:${hex.encode(input.message)}`
+    const key = `${input.did.verifiableDid.toString()}:${hex.encode(input.signature)}:${hex.encode(input.message)}:${input.strict === true}`
     if (cache.has(key)) {
       return cache.get(key)
     }
@@ -51,6 +51,7 @@ export class Resolver {
     this.registry = registry
     this.cache =
       options.cache === true ? memoryCache() : options.cache || noCache
+    this.strict = options.strict === true
   }
 
   /** @type {IResolver['verify']} */
@@ -60,6 +61,6 @@ export class Resolver {
       throw new TypeError(`Unsupported signature type "${input.type}"`)
     }
 
-    return this.cache(input, verify)
+    return this.cache({ ...input, strict: input.strict ?? this.strict }, verify)
   }
 }