@reclaimprotocol/client 0.1.11 → 0.1.13

package/lib/attestor-proof.js

@@ -12,9 +12,9 @@
  */
 import { keccak_256 } from '@noble/hashes/sha3.js';
 import { createSignDataForClaim } from '@reclaimprotocol/attestor-core';
+import { eip191Digest } from "./eip191.js";
 import { base64urlToBytes, bytesToHex } from "./encoding.js";
 import { secp } from "./secp.js";
-const ENC = new TextEncoder();
 function decodeJson(b64url) {
     return JSON.parse(new TextDecoder().decode(base64urlToBytes(b64url)));
 }
@@ -38,18 +38,6 @@ function createSignData(claim) {
         epoch: Number(claim.epoch ?? 0),
     });
 }
-/** Standard EIP-191 / personal_sign digest: keccak256 of
- *  `0x19 ‖ "Ethereum Signed Message:\n" ‖ len ‖ data`. */
-function eip191Digest(data) {
-    const bytes = ENC.encode(data);
-    const prefix = ENC.encode('\x19Ethereum Signed Message:\n');
-    const len = ENC.encode(String(bytes.length));
-    const merged = new Uint8Array(prefix.length + len.length + bytes.length);
-    merged.set(prefix, 0);
-    merged.set(len, prefix.length);
-    merged.set(bytes, prefix.length + len.length);
-    return keccak_256(merged);
-}
 /** Recover the lowercase ETH address from a 65-byte r‖s‖v signature. */
 function recoverEthAddress(digest, sig) {
     const v = sig[64];

package/lib/eip191.d.ts

@@ -0,0 +1,9 @@
+/** Standard EIP-191 / personal_sign digest: keccak256 of
+ *  `0x19 ‖ "Ethereum Signed Message:\n" ‖ len ‖ data`. */
+export declare function eip191Digest(data: string): Uint8Array;
+/** EIP-191 personal_sign over `message` with a raw 0x-hex eth private key.
+ *  Returns the standard 65-byte `r ‖ s ‖ v` hex signature that
+ *  `ethers.verifyMessage(message, signature)` accepts — noble's `'recovered'`
+ *  format prepends the recovery byte instead, so it's reordered to the end
+ *  here (a raw `0`/`1` recovery byte is fine there, no `+27` needed). */
+export declare function signEip191(message: string, privateKeyHex: string): string;

package/lib/eip191.js

@@ -0,0 +1,38 @@
+/**
+ * EIP-191 / `personal_sign` primitives shared by the verification paths
+ * (attestor-proof recovery) and by callers that need to *produce* a
+ * personal_sign signature with a raw eth key (e.g. the old-devtools
+ * link-app flow) — without pulling in a full wallet library.
+ */
+import { keccak_256 } from '@noble/hashes/sha3.js';
+import { bytesToHex, hexToBytes } from "./encoding.js";
+import { secp } from "./secp.js";
+const ENC = new TextEncoder();
+/** Standard EIP-191 / personal_sign digest: keccak256 of
+ *  `0x19 ‖ "Ethereum Signed Message:\n" ‖ len ‖ data`. */
+export function eip191Digest(data) {
+    const bytes = ENC.encode(data);
+    const prefix = ENC.encode('\x19Ethereum Signed Message:\n');
+    const len = ENC.encode(String(bytes.length));
+    const merged = new Uint8Array(prefix.length + len.length + bytes.length);
+    merged.set(prefix, 0);
+    merged.set(len, prefix.length);
+    merged.set(bytes, prefix.length + len.length);
+    return keccak_256(merged);
+}
+/** EIP-191 personal_sign over `message` with a raw 0x-hex eth private key.
+ *  Returns the standard 65-byte `r ‖ s ‖ v` hex signature that
+ *  `ethers.verifyMessage(message, signature)` accepts — noble's `'recovered'`
+ *  format prepends the recovery byte instead, so it's reordered to the end
+ *  here (a raw `0`/`1` recovery byte is fine there, no `+27` needed). */
+export function signEip191(message, privateKeyHex) {
+    const digest = eip191Digest(message);
+    const privateKey = hexToBytes(privateKeyHex);
+    const recovered = secp.sign(digest, privateKey, {
+        prehash: false,
+        format: 'recovered',
+    });
+    const recovery = recovered[0];
+    const rs = recovered.slice(1);
+    return '0x' + bytesToHex(rs) + recovery.toString(16).padStart(2, '0');
+}

package/lib/index.d.ts

@@ -7,6 +7,7 @@ export { addressFromPublicKey, deriveFromPrivateKey, type EthKeypair, generateKe
 export { canonicalJson } from './canonical.ts';
 export { b64url, base64urlToBytes, bytesToHex, hexToBytes, } from './encoding.ts';
 export { addressFromUncompressedPubkey, secp, } from './secp.ts';
+export { eip191Digest, signEip191 } from './eip191.ts';
 export { type CallbackBody, decodeJwsPayload, decryptCallback, type DeliveryEnvelope, encryptForEthPublicKey, type Jws, ResultVerificationError, type ResultProofOutcome, signResultJws, verifyJwsSignature, verifyResult, verifyResultFull, type VerifyResultFullOptions, type VerifyResultFullOutcome, type VerifyResultOptions, type VerifyResultOutcome, } from './result.ts';
 export { type DecryptionKey, type DecryptionKeyInput, generateEthKeypair, type GeneratedEthKeypair, loadDecryptionKey, pubkeyJwkToEthAddress, uncompressedPubkeyToJwk, } from './enckeys.ts';
 export { createReclaim, type CreateSessionInput, type Reclaim, type ReclaimConfig, type ReceiveOptions, type ReceivedDelivery, type RegisterCallbackInput, type SetKeypairInput, TERMINAL_EVENTS, } from './reclaim.ts';

package/lib/index.js

@@ -5,6 +5,7 @@ export { addressFromPublicKey, deriveFromPrivateKey, generateKeypair, } from "./
 export { canonicalJson } from "./canonical.js";
 export { b64url, base64urlToBytes, bytesToHex, hexToBytes, } from "./encoding.js";
 export { addressFromUncompressedPubkey, secp, } from "./secp.js";
+export { eip191Digest, signEip191 } from "./eip191.js";
 export { decodeJwsPayload, decryptCallback, encryptForEthPublicKey, ResultVerificationError, signResultJws, verifyJwsSignature, verifyResult, verifyResultFull, } from "./result.js";
 export { generateEthKeypair, loadDecryptionKey, pubkeyJwkToEthAddress, uncompressedPubkeyToJwk, } from "./enckeys.js";
 export { createReclaim, TERMINAL_EVENTS, } from "./reclaim.js";

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@reclaimprotocol/client",
 	"title": "Reclaim Client",
-	"version": "0.1.11",
+	"version": "0.1.13",
 	"description": "Typed SDK/HTTP client SDK for the Reclaim Protocol — the programmatic way to use Reclaim Protocol to verify **data points** about your users (a follower count, an account balance, an order). Can be directly integrated by apps to request verification for their users using Reclaim Protocol and verify the results.",
 	"type": "module",
 	"sideEffects": false,

package/src/attestor-proof.ts

@@ -12,11 +12,10 @@
  */
 import { keccak_256 } from '@noble/hashes/sha3.js'
 import { createSignDataForClaim } from '@reclaimprotocol/attestor-core'
+import { eip191Digest } from './eip191.ts'
 import { base64urlToBytes, bytesToHex } from './encoding.ts'
 import { secp } from './secp.ts'
 
-const ENC = new TextEncoder()
-
 function decodeJson(b64url: string): Record<string, unknown> {
 	return JSON.parse(new TextDecoder().decode(base64urlToBytes(b64url)))
 }
@@ -42,19 +41,6 @@ function createSignData(claim: Record<string, unknown>): string {
 	})
 }
 
-/** Standard EIP-191 / personal_sign digest: keccak256 of
- *  `0x19 ‖ "Ethereum Signed Message:\n" ‖ len ‖ data`. */
-function eip191Digest(data: string): Uint8Array {
-	const bytes = ENC.encode(data)
-	const prefix = ENC.encode('\x19Ethereum Signed Message:\n')
-	const len = ENC.encode(String(bytes.length))
-	const merged = new Uint8Array(prefix.length + len.length + bytes.length)
-	merged.set(prefix, 0)
-	merged.set(len, prefix.length)
-	merged.set(bytes, prefix.length + len.length)
-	return keccak_256(merged)
-}
-
 /** Recover the lowercase ETH address from a 65-byte r‖s‖v signature. */
 function recoverEthAddress(digest: Uint8Array, sig: Uint8Array): string {
 	const v = sig[64]

package/src/eip191.ts

@@ -0,0 +1,41 @@
+/**
+ * EIP-191 / `personal_sign` primitives shared by the verification paths
+ * (attestor-proof recovery) and by callers that need to *produce* a
+ * personal_sign signature with a raw eth key (e.g. the old-devtools
+ * link-app flow) — without pulling in a full wallet library.
+ */
+import { keccak_256 } from '@noble/hashes/sha3.js'
+import { bytesToHex, hexToBytes } from './encoding.ts'
+import { secp } from './secp.ts'
+
+const ENC = new TextEncoder()
+
+/** Standard EIP-191 / personal_sign digest: keccak256 of
+ *  `0x19 ‖ "Ethereum Signed Message:\n" ‖ len ‖ data`. */
+export function eip191Digest(data: string): Uint8Array {
+	const bytes = ENC.encode(data)
+	const prefix = ENC.encode('\x19Ethereum Signed Message:\n')
+	const len = ENC.encode(String(bytes.length))
+	const merged = new Uint8Array(prefix.length + len.length + bytes.length)
+	merged.set(prefix, 0)
+	merged.set(len, prefix.length)
+	merged.set(bytes, prefix.length + len.length)
+	return keccak_256(merged)
+}
+
+/** EIP-191 personal_sign over `message` with a raw 0x-hex eth private key.
+ *  Returns the standard 65-byte `r ‖ s ‖ v` hex signature that
+ *  `ethers.verifyMessage(message, signature)` accepts — noble's `'recovered'`
+ *  format prepends the recovery byte instead, so it's reordered to the end
+ *  here (a raw `0`/`1` recovery byte is fine there, no `+27` needed). */
+export function signEip191(message: string, privateKeyHex: string): string {
+	const digest = eip191Digest(message)
+	const privateKey = hexToBytes(privateKeyHex)
+	const recovered = secp.sign(digest, privateKey, {
+		prehash: false,
+		format: 'recovered',
+	}) as Uint8Array
+	const recovery = recovered[0]
+	const rs = recovered.slice(1)
+	return '0x' + bytesToHex(rs) + recovery.toString(16).padStart(2, '0')
+}

package/src/index.ts

@@ -20,6 +20,7 @@ export {
 	addressFromUncompressedPubkey,
 	secp,
 } from './secp.ts'
+export { eip191Digest, signEip191 } from './eip191.ts'
 export {
 	type CallbackBody,
 	decodeJwsPayload,

package/src/types/openapi.ts

@@ -7,8 +7,8 @@ export type RequestBodyContent<T> = T extends {
 }
 	? R
 	: T extends { content: { 'application/x-www-form-urlencoded': infer R } }
-	? R
-	: undefined
+		? R
+		: undefined
 
 export type IJsonRequestBody<T extends IOperationId> = operations[T] extends {
 	requestBody?: infer B
@@ -21,10 +21,10 @@ type AnySuccess<R> = R extends {
 }
 	? J
 	: R extends { 201: { content: { 'application/json': infer J } } }
-	? J
-	: R extends { 204: unknown }
-	? void
-	: unknown
+		? J
+		: R extends { 204: unknown }
+			? void
+			: unknown
 
 export type IJsonResponseBody<T extends IOperationId> = operations[T] extends {
 	responses: infer R
@@ -66,8 +66,8 @@ export type IOperationArgs<T extends IOperationId> = {
 		[IQuery<T>] extends [undefined] ? unknown : { query: IQuery<T> }
 	) & (
 		[IJsonRequestBody<T>] extends [undefined]
-		? unknown
-		: { body: IJsonRequestBody<T> }
+			? unknown
+			: { body: IJsonRequestBody<T> }
 	) & (
 		[IHeaders<T>] extends [undefined] ? unknown : { headers: IHeaders<T> }
 	)