iso-signatures 0.5.2 → 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 & Uint8Array<ArrayBuffer>>;
+    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,qEAIpB;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

@@ -159,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";
@@ -266,7 +272,7 @@ export class EIP191Signer extends DID implements ISigner {
                 method: "eth_simulateV1";
                 params: [{
                     blockStateCalls: readonly {
-                        blockOverrides?: import("viem").RpcBlockOverrides | undefined;
+                        blockOverrides?: import("ox/BlockOverrides").Rpc | undefined;
                         calls?: readonly import("ox/TransactionRequest").Rpc[] | undefined;
                         stateOverrides?: import("ox/StateOverrides").Rpc | undefined;
                     }[];

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

@@ -1 +1 @@
-{"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"}
+{"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 & Uint8Array<ArrayBuffer>>;
+    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,uEAKpB;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.map

@@ -1 +1 @@
-{"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"}
+{"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/package.json

@@ -1,7 +1,7 @@
 {
   "name": "iso-signatures",
   "type": "module",
-  "version": "0.5.2",
+  "version": "0.6.0",
   "description": "Signatures tooling.",
   "author": "Hugo Dias <hugomrdias@gmail.com> (hugodias.me)",
   "license": "MIT",
@@ -81,24 +81,24 @@
     "dist/src/**/*.d.ts.map"
   ],
   "dependencies": {
-    "@noble/ed25519": "^3.0.1",
-    "@noble/hashes": "^2.0.0",
-    "@noble/secp256k1": "^3.0.0",
+    "@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": "^2.1.1",
-    "ox": "^0.14.30"
+    "iso-did": "^3.0.0",
+    "ox": "^0.14.49"
   },
   "devDependencies": {
     "@types/assert": "^1.5.11",
     "@types/mocha": "^10.0.10",
-    "@types/node": "^26.1.1",
+    "@types/node": "^26.6.2",
     "assert": "^2.1.0",
-    "mocha": "^11.7.5",
-    "playwright-test": "^14.1.13",
-    "type-fest": "^5.8.0",
+    "mocha": "^12.0.2",
+    "playwright-test": "^15.0.1",
+    "type-fest": "^5.10.0",
     "typescript": "^6.0.3",
-    "viem": "^2.54.6"
+    "viem": "~2.56.9"
   },
   "publishConfig": {
     "provenance": true

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/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

@@ -6,7 +6,6 @@ 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'
 
@@ -28,15 +27,26 @@ export function getSignPayload(data) {
 }
 
 /** @type {import('../types.js').Verify} */
-export async function verify({ signature, message, did }) {
+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 sigRecovered = Signature.fromBytes(signature.slice(0, 64))
-    .addRecoveryBit(SignatureOx.vToYParity(signature[64]))
-    .toBytes('recovered')
+  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),

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