@qntx/siwx 0.0.0-stage → 0.7.0

package/dist/evm.mjs

@@ -0,0 +1,289 @@
+import { g as createAccountId, i as utf8Encode, v as SiwxError, y as fieldError } from "./message-ZewmOzps.mjs";
+import { n as format, r as parseLabeled } from "./eip4361-XA-TUOKF.mjs";
+import { hexToBytes } from "@noble/hashes/utils.js";
+import { keccak_256 } from "@noble/hashes/sha3.js";
+import { secp256k1 } from "@noble/curves/secp256k1.js";
+import { bytesToHex, bytesToNumberBE, equalBytes, hexToBytes as hexToBytes$1, numberToBytesBE } from "@noble/curves/utils.js";
+//#region src/evm/address.ts
+//! EIP-55 / EVM address + chain-id rules, matching `siwx::evm`.
+const HEX40 = /^[0-9a-fA-F]{40}$/;
+/** EIP-55 checksum spelling of a `0x`-prefixed 40-hex address. */
+function toChecksumAddress(address) {
+	if (!address.startsWith("0x")) throw fieldError("address", "expected 0x + 40 hex");
+	const body = address.slice(2);
+	if (!HEX40.test(body)) throw fieldError("address", "expected 0x + 40 hex");
+	const lower = body.toLowerCase();
+	const hash = keccak_256(utf8Encode(lower));
+	let out = "0x";
+	for (let i = 0; i < 40; i++) {
+		const c = lower.charAt(i);
+		const nibble = (hash[Math.floor(i / 2)] ?? 0) >> (i % 2 === 0 ? 4 : 0) & 15;
+		out += /[a-f]/.test(c) && nibble >= 8 ? c.toUpperCase() : c;
+	}
+	return out;
+}
+/**
+* Validate `0x` + 40 hex: all-lowercase/all-uppercase or valid EIP-55.
+*
+* @throws {SiwxError} `InvalidField` `address`.
+*/
+function validateAddress(address) {
+	parseEip55(address);
+}
+const badAddress = () => fieldError("address", "expected 0x + 40 hex");
+/** Parse an EVM address to its 20 bytes under the canonical rule. */
+function parseEip55(address) {
+	const bad = badAddress;
+	if (!address.startsWith("0x")) throw bad();
+	const hex = address.slice(2);
+	if (!HEX40.test(hex)) throw bad();
+	const hasLower = /[a-f]/.test(hex);
+	const hasUpper = /[A-F]/.test(hex);
+	if (hasLower && hasUpper && address !== toChecksumAddress(address)) throw fieldError("address", "bad EIP-55 checksum");
+	return hexToBytes(hex);
+}
+/**
+* EVM `chain-id`: `[0-9]+`, no leading zero unless `"0"`, fits in `u64`.
+*
+* @throws {SiwxError} `InvalidField` `chainId`.
+*/
+function parseEvmChainId(chainId) {
+	if (chainId.length === 0) throw fieldError("chainId", "empty");
+	if (!/^[0-9]+$/.test(chainId)) throw fieldError("chainId", "not decimal");
+	if (chainId.length > 1 && chainId.startsWith("0")) throw fieldError("chainId", "leading zero");
+	const value = BigInt(chainId);
+	if (value > 18446744073709551615n) throw fieldError("chainId", "overflow");
+	return value;
+}
+//#endregion
+//#region src/evm/eip191.ts
+//! EIP-191 `personal_sign` verification.
+//!
+//! Decode order (cross-language contract, mirrored with Rust): length ≠
+//! 65 → `v ∉ {0,1,27,28}` → `r`/`s` equal to 0 or ≥ n → `s > n/2` (all
+//! `InvalidSignature`) → recovery failure or address mismatch →
+//! `VerificationFailed`.
+const N = secp256k1.Point.Fn.ORDER;
+const N_HALF = N / 2n;
+/** `keccak256("\x19Ethereum Signed Message:\n" + len + message)`. */
+function eip191Hash(message) {
+	const prefix = utf8Encode(`\u0019Ethereum Signed Message:\n${message.length}`);
+	const joined = new Uint8Array(prefix.length + message.length);
+	joined.set(prefix);
+	joined.set(message, prefix.length);
+	return keccak_256(joined);
+}
+/** Verify a 65-byte `r‖s‖v` EIP-191 signature over `signed`. */
+function verifyEip191(message, signed, signature) {
+	if (signature.length !== 65) throw new SiwxError({
+		code: "InvalidSignature",
+		reason: "EIP-191 signature must be 65 bytes"
+	});
+	const v = signature[64] ?? 0;
+	if (v !== 0 && v !== 1 && v !== 27 && v !== 28) throw new SiwxError({
+		code: "InvalidSignature",
+		reason: "v must be 0, 1, 27 or 28"
+	});
+	const r = bytesToNumberBE(signature.subarray(0, 32));
+	const s = bytesToNumberBE(signature.subarray(32, 64));
+	if (r === 0n || r >= N || s === 0n || s >= N) throw new SiwxError({
+		code: "InvalidSignature",
+		reason: "r/s out of range"
+	});
+	if (s > N_HALF) throw new SiwxError({
+		code: "InvalidSignature",
+		reason: "high-s (EIP-2)"
+	});
+	const hash = eip191Hash(signed);
+	let recovered;
+	try {
+		const uncompressed = secp256k1.Signature.fromBytes(signature.subarray(0, 64), "compact").addRecoveryBit(v % 27).recoverPublicKey(hash).toBytes(false);
+		recovered = keccak_256(uncompressed.subarray(1)).subarray(12);
+	} catch {
+		throw new SiwxError({ code: "VerificationFailed" });
+	}
+	const expected = parseEip55(message.address);
+	if (!equalBytes(recovered, expected)) throw new SiwxError({ code: "VerificationFailed" });
+}
+//#endregion
+//#region src/evm/validator.ts
+//! On-chain smart-account verification: the ERC-6492 universal validator via a
+//! deployless `eth_call`. Covers deployed ERC-1271 accounts, counterfactual
+//! ERC-6492 accounts and EOAs. Providers are injected; the library builds no
+//! transports and applies no timeouts — transport policy belongs to the
+//! provider owner.
+const BYTECODE = hexToBytes$1("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");
+/** Abi.encode(address signer, bytes32 hash, bytes signature). */
+function deploylessCalldata(signer, hash, signature) {
+	const addr = hexToBytes$1(signer.slice(2));
+	const word = 32;
+	const out = new Uint8Array(BYTECODE.length + 96 + word + Math.ceil(signature.length / word) * word);
+	const bc = BYTECODE;
+	out.set(bc, 0);
+	let o = bc.length;
+	out.set(addr, o + (word - addr.length));
+	o += word;
+	out.set(hash, o);
+	o += word;
+	out.set(numberToBytesBE(BigInt(96), word), o);
+	o += word;
+	out.set(numberToBytesBE(BigInt(signature.length), word), o);
+	out.set(signature, o + word);
+	return out;
+}
+const malformed = () => new SiwxError({
+	code: "Backend",
+	reason: "malformed eth_call result"
+});
+/**
+* Interpret a deployless validator `eth_call` result: `0x01` or a 32-byte word of zeros ending `01`
+* is valid; the same shapes ending `00` are `false`; anything else is malformed.
+*/
+function decodeResult(hex) {
+	const data = hex === "" || hex === "0x" ? /* @__PURE__ */ new Uint8Array(0) : hexToBytes$1(hex.slice(2));
+	if (data.length === 1) {
+		if (data[0] === 1) return true;
+		if (data[0] === 0) return false;
+		throw malformed();
+	}
+	if (data.length === 32) {
+		for (let i = 0; i < 31; i++) if (data[i] !== 0) throw malformed();
+		if (data[31] === 1) return true;
+		if (data[31] === 0) return false;
+	}
+	throw malformed();
+}
+/** JSON-RPC code 3 (EIP-1474 execution reverted) ⇒ signature rejected. */
+const codeOf = (error) => typeof error === "object" && error !== null && "code" in error ? error.code : void 0;
+function isRevert(error) {
+	const code = codeOf(error);
+	return typeof code === "number" && code === 3;
+}
+function backend() {
+	return new SiwxError({
+		code: "Backend",
+		reason: "RPC request failed"
+	});
+}
+const MAGIC = (() => {
+	const m = /* @__PURE__ */ new Uint8Array(32);
+	for (let i = 0; i < m.length; i++) m[i] = i % 2 === 0 ? 100 : 146;
+	return m;
+})();
+/** True when `signature` ends with the ERC-6492 detection suffix. */
+function has6492MagicSuffix(signature) {
+	if (signature.length < MAGIC.length) return false;
+	for (let i = 0; i < MAGIC.length; i++) if (signature[signature.length - MAGIC.length + i] !== MAGIC[i]) return false;
+	return true;
+}
+/** `eth_chainId` as a decimal number; malformed → `Backend`. */
+async function providerChainId(provider) {
+	let result;
+	try {
+		result = await provider.request({ method: "eth_chainId" });
+	} catch {
+		throw backend();
+	}
+	if (typeof result !== "string" || !/^0x[0-9a-fA-F]+$/.test(result)) throw backend();
+	return BigInt(result);
+}
+/**
+* Deployless `eth_call` against the vendored universal validator. `provider`'s chain id must
+* already equal the message chain id (the caller caches the binding).
+*/
+async function verifyOnChain(provider, message, signed, signature) {
+	parseEip55(message.address);
+	const hash = eip191Hash(signed);
+	const data = `0x${bytesToHex(deploylessCalldata(message.address, hash, signature))}`;
+	let result;
+	try {
+		result = await provider.request({
+			method: "eth_call",
+			params: [{
+				data,
+				input: data
+			}, "latest"]
+		});
+	} catch (error) {
+		throw isRevert(error) ? new SiwxError({ code: "VerificationFailed" }) : backend();
+	}
+	if (typeof result !== "string" || !/^0x[0-9a-fA-F]*$/.test(result)) throw backend();
+	if (!decodeResult(result)) throw new SiwxError({ code: "VerificationFailed" });
+}
+//#endregion
+//#region src/evm/index.ts
+//! `@qntx/siwx/evm` — EIP-155 (`eip155`) namespace profile.
+//!
+//! `account()` emits the canonical EIP-55 checksum spelling, so
+//! lowercase / uppercase / checksummed spellings of the same address map
+//! to the same `AccountId`.
+const CHAIN_NAME = "Ethereum";
+const NAMESPACE = "eip155";
+function evmAccount(message) {
+	parseEip55(message.address);
+	parseEvmChainId(message.chainId);
+	return createAccountId(NAMESPACE, message.chainId, toChecksumAddress(message.address));
+}
+/**
+* Ethereum (`eip155`) namespace. EIP-191 runs fully offline; a signature carrying the ERC-6492
+* magic suffix, or an EIP-191 failure on a chain with a configured provider, takes the on-chain
+* universal-validator path. Providers own all transport policy — the library applies no timeouts —
+* and `eth_chainId` is bound to the message chain id (cached per provider on success only) before
+* any `eth_call`.
+*/
+function evm(options) {
+	const rpc = options?.rpc ?? {};
+	const verifiedChains = /* @__PURE__ */ new Set();
+	const providerFor = (chainId) => {
+		const key = parseEvmChainId(chainId).toString(10);
+		return rpc[key];
+	};
+	const onChain = async (message, signed, signature, eip191Err) => {
+		const key = parseEvmChainId(message.chainId).toString(10);
+		const provider = providerFor(message.chainId);
+		if (provider === void 0) throw eip191Err ?? new SiwxError({
+			code: "Unsupported",
+			reason: "EIP-6492 requires RPC"
+		});
+		if (!verifiedChains.has(key)) {
+			const rpcChain = await providerChainId(provider);
+			if (rpcChain !== parseEvmChainId(message.chainId)) throw new SiwxError({
+				code: "Mismatch",
+				field: "chainId",
+				expected: key,
+				actual: rpcChain.toString()
+			});
+			verifiedChains.add(key);
+		}
+		await verifyOnChain(provider, message, signed, signature);
+	};
+	return {
+		namespace: NAMESPACE,
+		label: CHAIN_NAME,
+		account: evmAccount,
+		format(message) {
+			evmAccount(message);
+			return format(CHAIN_NAME, message);
+		},
+		parse(signed) {
+			return parseLabeled(CHAIN_NAME, signed);
+		},
+		verify: async (message, signed, signature) => {
+			if (has6492MagicSuffix(signature)) {
+				await onChain(message, signed, signature, void 0);
+				return;
+			}
+			try {
+				verifyEip191(message, signed, signature);
+			} catch (error) {
+				if (error instanceof SiwxError && providerFor(message.chainId) !== void 0) {
+					await onChain(message, signed, signature, error);
+					return;
+				}
+				throw error;
+			}
+		}
+	};
+}
+//#endregion
+export { evm, parseEvmChainId, toChecksumAddress, validateAddress };

package/dist/index.d.mts

@@ -0,0 +1,113 @@
+import { a as checkExpect, c as createMessage, d as parseAccountId, i as Expect, l as AccountId, n as Namespace, o as Message, r as authenticate, s as MessageFields, t as Authenticated, u as createAccountId } from "./namespace-DlgXqLsI.mjs";
+declare namespace eip4361_d_exports {
+  export { Parsed, format, parse, parseBytes, parseLabeled };
+}
+/** Result of [`parse`]: preamble label plus the validated message. */
+type Parsed = {
+  readonly label: string;
+  readonly message: Message;
+};
+/** Render `message` as an ERC-4361 signing text under `label`. */
+declare function format(label: string, message: Message): string;
+/** Parse `text` into a label + validated message. */
+declare function parse(text: string): Parsed;
+/** [`parseBytes`]: UTF-8 strictness then [`parse`]. */
+declare function parseBytes(bytes: Uint8Array): Parsed;
+/** [`parseBytes`] plus a required preamble `label`. */
+declare function parseLabeled(label: string, signed: Uint8Array): Message;
+//#endregion
+//#region src/core/error.d.ts
+/** CAIP-122 message field or preamble component, camelCase-named. */
+type Field = "label" | "scheme" | "domain" | "address" | "statement" | "uri" | "version" | "chainId" | "nonce" | "issuedAt" | "expirationTime" | "notBefore" | "requestId" | "resources";
+/** Layout-level (ABNF) syntax failure kinds. */
+type SyntaxKind = "InvalidUtf8" | "CarriageReturn" | "MissingPreamble" | "MissingAccountSuffix" | "UnexpectedEof" | "ExpectedBlankLine" | "MissingField" | "UnexpectedTrailing" | "ResourceSyntax" | "InvalidEnvelope";
+/** Per-code error detail; `switch (info.code)` narrows the payload. */
+type SiwxErrorInfo = Readonly<{
+  code: "MessageTooLarge";
+  length: number;
+  max: number;
+}> | Readonly<{
+  code: "Syntax";
+  syntax: "MissingField";
+  field: Field;
+}> | Readonly<{
+  code: "Syntax";
+  syntax: Exclude<SyntaxKind, "MissingField">;
+}> | Readonly<{
+  code: "InvalidField";
+  field: Field;
+  reason: string;
+}> | Readonly<{
+  code: "Mismatch";
+  field: Field;
+  expected: string;
+  actual: string | undefined;
+}> | Readonly<{
+  code: "Expired";
+}> | Readonly<{
+  code: "NotYetValid";
+}> | Readonly<{
+  code: "IssuedAtTooOld";
+}> | Readonly<{
+  code: "InvalidSignature";
+  reason: string;
+}> | Readonly<{
+  code: "VerificationFailed";
+}> | Readonly<{
+  code: "Unsupported";
+  reason: string;
+}> | Readonly<{
+  code: "Backend";
+  reason: string;
+}>;
+/** Stable error code set shared with the Rust implementation. */
+type SiwxErrorCode = SiwxErrorInfo["code"];
+/** The single error type thrown by every library failure. */
+export declare class SiwxError extends Error {
+  /** Structured payload; `code` matches the Rust `Error::code()`. */
+  readonly info: SiwxErrorInfo;
+  constructor(info: SiwxErrorInfo);
+  /** Stable variant name for cross-language contract tests. */
+  get code(): SiwxErrorCode;
+}
+//#endregion
+//#region src/core/limits.d.ts
+/** Minimum EIP-4361 nonce length. */
+export declare const MIN_NONCE_LEN = 8;
+/** Maximum accepted signing-text size in bytes. */
+export declare const MAX_MESSAGE_BYTES = 16384;
+/** Maximum number of entries in the `Resources` list. */
+export declare const MAX_RESOURCES = 32;
+/** Maximum accepted `statement` size in bytes. */
+export declare const MAX_STATEMENT_BYTES = 4096;
+/** Maximum accepted `request_id` size in bytes. */
+export declare const MAX_REQUEST_ID_BYTES = 128;
+/** Maximum accepted URI size in bytes (`uri` and each resource). */
+export declare const MAX_URI_BYTES = 2048;
+//#endregion
+//#region src/core/nonce.d.ts
+/** Generate a random nonce: 17 unbiased ASCII alphanumerics (≥ 8 required). */
+export declare function generateNonce(): string;
+//#endregion
+//#region src/core/timestamp.d.ts
+/** Parsed RFC 3339 timestamp: original lexeme + epoch milliseconds. */
+type Timestamp = {
+  /** Original RFC 3339 lexical form (formatter input). */
+  readonly lexeme: string;
+  /** Instant in whole milliseconds since the Unix epoch. */
+  readonly epochMs: number;
+};
+/**
+ * Parse an RFC 3339 `date-time`; `undefined` when invalid.
+ *
+ * Requires `T`/`t` and `Z`/`z`/`±HH:MM`; optional fraction; real calendar validity (Feb 30
+ * rejected); leap second `:60` rejected like Rust `time`.
+ */
+export declare function parseTimestamp(s: string): Timestamp | undefined;
+/**
+ * `Date.prototype.toISOString()` semantics: UTC, millisecond precision, `YYYY-MM-DDTHH:MM:SS.sssZ`;
+ * `undefined` for invalid dates and years outside `0000..=9999`.
+ */
+export declare function timestampFromDate(date: Date): string | undefined;
+//#endregion
+export { type AccountId, type Authenticated, type Expect, type Field, type Message, type MessageFields, type Namespace, type Parsed, type SiwxErrorCode, type SiwxErrorInfo, type SyntaxKind, type Timestamp, authenticate, checkExpect, createAccountId, createMessage, eip4361_d_exports as eip4361, parseAccountId };

package/dist/index.mjs

@@ -0,0 +1,32 @@
+import { _ as parseAccountId, a as parseTimestamp, c as MAX_REQUEST_ID_BYTES, d as MAX_URI_BYTES, f as MIN_NONCE_LEN, g as createAccountId, l as MAX_RESOURCES, o as timestampFromDate, s as MAX_MESSAGE_BYTES, t as createMessage, u as MAX_STATEMENT_BYTES, v as SiwxError } from "./message-ZewmOzps.mjs";
+import { t as eip4361_exports } from "./eip4361-XA-TUOKF.mjs";
+import { r as checkExpect, t as authenticate } from "./namespace-Cl7PJYC-.mjs";
+import { randomBytes } from "@noble/hashes/utils.js";
+//#region src/core/nonce.ts
+//! Cryptographically secure nonce generation (17 unbiased ASCII
+//! alphanumerics via rejection sampling over `randomBytes`).
+const ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+const LEN = 17;
+/** Generate a random nonce: 17 unbiased ASCII alphanumerics (≥ 8 required). */
+function generateNonce() {
+	let out = "";
+	while (out.length < LEN) {
+		const bytes = randomBytes(34);
+		for (const b of bytes) if (b < 248) {
+			out += ALPHABET[b % 62];
+			if (out.length === LEN) break;
+		}
+	}
+	return out;
+}
+//#endregion
+//#region src/index.ts
+//! `@qntx/siwx` — Sign-In with X (CAIP-122) for TypeScript.
+//!
+//! Mirrors the `siwx` Rust crate 1:1: same error codes, field names,
+//! validation order, layout, and `Expect` semantics; both languages run
+//! the same vector files in `vectors/`.
+//!
+//! The Ethereum namespace lives at `@qntx/siwx/evm`.
+//#endregion
+export { MAX_MESSAGE_BYTES, MAX_REQUEST_ID_BYTES, MAX_RESOURCES, MAX_STATEMENT_BYTES, MAX_URI_BYTES, MIN_NONCE_LEN, SiwxError, authenticate, checkExpect, createAccountId, createMessage, eip4361_exports as eip4361, generateNonce, parseAccountId, parseTimestamp, timestampFromDate };