@qntx/siwx 0.0.0-stage → 0.7.0

package/dist/rolldown-runtime-D7D4PA-g.mjs

@@ -0,0 +1,13 @@
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+export { __exportAll as t };

package/dist/svm.d.mts

@@ -0,0 +1,42 @@
+import { n as Namespace, o as Message } from "./namespace-DlgXqLsI.mjs";
+//#region src/svm/address.d.ts
+/**
+ * Validate that `address` is a canonical, non-identity, prime-order-subgroup Ed25519 verifying key
+ * in base58 form.
+ *
+ * @throws {SiwxError} `InvalidField` `address`.
+ */
+export declare function validateAddress(address: string): void;
+declare namespace siws_d_exports {
+  export { format, parse, parseBytes };
+}
+/**
+ * Format `message` as a SIWS signing text.
+ *
+ * @throws {SiwxError} `InvalidField` `scheme` (SIWS has none) or `statement` (empty).
+ */
+declare function format(message: Message): string;
+/**
+ * Parse `text` into a validated message; the preamble label must be exactly `"Solana"`.
+ *
+ * @throws {SiwxError} `Syntax`, `Mismatch` `label`, or `InvalidField`.
+ */
+declare function parse(text: string): Message;
+/**
+ * {@link parse} over raw bytes: size check, strict UTF-8 (`InvalidUtf8`), then parse.
+ *
+ * @throws {SiwxError}
+ */
+declare function parseBytes(bytes: Uint8Array): Message;
+//#endregion
+//#region src/svm/index.d.ts
+/**
+ * Wrap `text` in the off-chain message v1 envelope for `signer` (validated as an SIWS address).
+ *
+ * @throws {SiwxError} `InvalidField` `address`.
+ */
+export declare function offchainMessage(text: string, signer: string): Uint8Array;
+/** Create the Solana namespace profile. */
+export declare function svm(): Namespace;
+//#endregion
+export { siws_d_exports as siws };

package/dist/svm.mjs

@@ -0,0 +1,329 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { g as createAccountId, h as optionalTags, i as utf8Encode, m as SUFFIX, n as utf8ByteLength, p as MID, r as utf8Decode, s as MAX_MESSAGE_BYTES, t as createMessage, v as SiwxError, x as syntaxError, y as fieldError } from "./message-ZewmOzps.mjs";
+import { n as settle } from "./namespace-Cl7PJYC-.mjs";
+import { bytesToNumberLE, equalBytes } from "@noble/curves/utils.js";
+import { ed25519 } from "@noble/curves/ed25519.js";
+import { base58 } from "@scure/base";
+//#region src/svm/address.ts
+/** Solana address rules: canonical on-curve Ed25519 key in base58. */
+/**
+* Decode `address` as a base58 (Bitcoin alphabet) string of 32–44 chars that decodes to exactly 32
+* bytes.
+*
+* @throws {SiwxError} `InvalidField` `address`.
+*/
+function addressBytes(address) {
+	if (address.length < 32 || address.length > 44) throw fieldError("address", "expected 32–44 base58 chars");
+	let bytes;
+	try {
+		bytes = base58.decode(address);
+	} catch {
+		throw fieldError("address", "invalid base58");
+	}
+	if (bytes.length !== 32) throw fieldError("address", "expected 32 bytes");
+	return bytes;
+}
+/**
+* The canonical, non-identity, prime-order-subgroup Ed25519 point for `bytes` (decompress →
+* recompress byte equality proves canonicity).
+*
+* @throws {SiwxError} `InvalidField` `address`.
+*/
+function canonicalPoint(bytes) {
+	let point;
+	try {
+		point = ed25519.Point.fromBytes(bytes);
+	} catch {
+		throw fieldError("address", "invalid Ed25519 pubkey");
+	}
+	if (point.equals(ed25519.Point.ZERO)) throw fieldError("address", "identity pubkey");
+	if (!point.isTorsionFree()) throw fieldError("address", "not in the prime-order subgroup");
+	if (!equalBytes(point.toBytes(), bytes)) throw fieldError("address", "non-canonical pubkey");
+}
+/**
+* Validate that `address` is a canonical, non-identity, prime-order-subgroup Ed25519 verifying key
+* in base58 form.
+*
+* @throws {SiwxError} `InvalidField` `address`.
+*/
+function validateAddress(address) {
+	canonicalPoint(addressBytes(address));
+}
+/** Base58-encode `bytes` (error messages). */
+function b58(bytes) {
+	return base58.encode(bytes);
+}
+//#endregion
+//#region src/svm/ed25519.ts
+/** Ed25519 signature verification for Solana (internal). */
+const L = ed25519.Point.CURVE().n;
+const P = ed25519.Point;
+/**
+* RFC 8032 verification over the exact `signed` bytes.
+*
+* `A` (the address key) and `R` must be canonical encodings of prime-order-subgroup points
+* (torsion-free — excluding identity, small-order and mixed points) and `S < L`; for torsion-free
+* `A`/`R` the cofactored and cofactorless equations coincide, so library verifiers agree.
+*
+* @throws {SiwxError} `InvalidSignature` (wrong length or `S >= L`) or `VerificationFailed` (bad
+*   `R`, or the equation fails).
+*/
+function verifyEddsa(message, signed, signature) {
+	if (signature.length !== 64) throw new SiwxError({
+		code: "InvalidSignature",
+		reason: "Ed25519 signature must be 64 bytes"
+	});
+	if (bytesToNumberLE(signature.subarray(32, 64)) >= L) throw new SiwxError({
+		code: "InvalidSignature",
+		reason: "S must be a canonical scalar (S < L)"
+	});
+	const key = addressBytes(message.address);
+	canonicalPoint(key);
+	const rBytes = signature.subarray(0, 32);
+	let r;
+	try {
+		r = P.fromBytes(rBytes);
+	} catch {
+		throw new SiwxError({ code: "VerificationFailed" });
+	}
+	if (!equalBytes(r.toBytes(), rBytes) || !r.isTorsionFree() || r.equals(P.ZERO)) throw new SiwxError({ code: "VerificationFailed" });
+	let ok;
+	try {
+		ok = ed25519.verify(signature, signed, key, { zip215: false });
+	} catch {
+		throw new SiwxError({ code: "VerificationFailed" });
+	}
+	if (!ok) throw new SiwxError({ code: "VerificationFailed" });
+}
+//#endregion
+//#region src/svm/siws.ts
+/** SIWS (Sign-In-With-Solana) text layout — Phantom ABNF, LF only. */
+var siws_exports = /* @__PURE__ */ __exportAll({
+	format: () => format,
+	parse: () => parse,
+	parseBytes: () => parseBytes
+});
+const LABEL = "Solana";
+/**
+* Format `message` as a SIWS signing text.
+*
+* @throws {SiwxError} `InvalidField` `scheme` (SIWS has none) or `statement` (empty).
+*/
+function format(message) {
+	if (message.scheme !== void 0) throw new SiwxError({
+		code: "InvalidField",
+		field: "scheme",
+		reason: "not supported by SIWS"
+	});
+	if (message.statement !== void 0) {
+		if (message.statement === "") throw new SiwxError({
+			code: "InvalidField",
+			field: "statement",
+			reason: "empty"
+		});
+		if (message.statement.startsWith("URI: ")) throw new SiwxError({
+			code: "InvalidField",
+			field: "statement",
+			reason: "ambiguous with the URI: tag"
+		});
+	}
+	let out = `${message.domain}${MID}${LABEL}${SUFFIX}\n${message.address}`;
+	if (message.statement !== void 0) out += `\n\n${message.statement}`;
+	out += `\n\nURI: ${message.uri}`;
+	out += `\nVersion: ${message.version}`;
+	out += `\nChain ID: ${message.chainId}`;
+	out += `\nNonce: ${message.nonce}`;
+	out += `\nIssued At: ${message.issuedAt}`;
+	if (message.expirationTime !== void 0) out += `\nExpiration Time: ${message.expirationTime}`;
+	if (message.notBefore !== void 0) out += `\nNot Before: ${message.notBefore}`;
+	if (message.requestId !== void 0) out += `\nRequest ID: ${message.requestId}`;
+	if (message.resources !== void 0) {
+		out += "\nResources:";
+		for (const r of message.resources) out += `\n- ${r}`;
+	}
+	return out;
+}
+const missingUri = () => syntaxError("MissingField", "uri");
+/** The optional statement and the gap up to the required `URI: ` line. */
+function statementThenFields(lines, i) {
+	if (i.v >= lines.length) throw missingUri();
+	if (lines[i.v] !== "") throw syntaxError("ExpectedBlankLine");
+	i.v++;
+	const l = lines[i.v];
+	if (l === void 0) throw missingUri();
+	if (l === "") throw syntaxError("ExpectedBlankLine");
+	if (l.startsWith("URI: ")) return;
+	i.v++;
+	const after = lines[i.v];
+	if (after === void 0) throw missingUri();
+	if (after !== "") throw syntaxError("ExpectedBlankLine");
+	i.v++;
+	return l;
+}
+/**
+* Parse `text` into a validated message; the preamble label must be exactly `"Solana"`.
+*
+* @throws {SiwxError} `Syntax`, `Mismatch` `label`, or `InvalidField`.
+*/
+function parse(text) {
+	const byteLength = utf8ByteLength(text);
+	if (byteLength > 16384) throw new SiwxError({
+		code: "MessageTooLarge",
+		length: byteLength,
+		max: MAX_MESSAGE_BYTES
+	});
+	if (text.includes("\r")) throw syntaxError("CarriageReturn");
+	if (text.endsWith("\n")) throw syntaxError("UnexpectedTrailing");
+	const lines = text.split("\n");
+	const idx = { v: 0 };
+	const preamble = lines[idx.v++];
+	if (preamble === void 0) throw syntaxError("UnexpectedEof");
+	const mid = preamble.indexOf(MID);
+	if (mid === -1) throw syntaxError("MissingPreamble");
+	const domain = preamble.slice(0, mid);
+	const tail = preamble.slice(mid + MID.length);
+	if (!tail.endsWith(" account:")) throw syntaxError("MissingAccountSuffix");
+	const label = tail.slice(0, tail.length - SUFFIX.length);
+	if (label !== LABEL) throw new SiwxError({
+		code: "Mismatch",
+		field: "label",
+		expected: LABEL,
+		actual: label
+	});
+	const address = lines[idx.v++];
+	if (address === void 0) throw syntaxError("UnexpectedEof");
+	const statement = statementThenFields(lines, idx);
+	const take = (tag, field) => {
+		const line = lines[idx.v];
+		if (line === void 0 || !line.startsWith(tag)) throw syntaxError("MissingField", field);
+		idx.v++;
+		return line.slice(tag.length);
+	};
+	const uri = take("URI: ", "uri");
+	const version = take("Version: ", "version");
+	const chainId = take("Chain ID: ", "chainId");
+	const nonce = take("Nonce: ", "nonce");
+	const issuedAt = take("Issued At: ", "issuedAt");
+	const tail4 = optionalTags(lines, idx.v);
+	return createMessage({
+		domain,
+		address,
+		...statement === void 0 ? {} : { statement },
+		uri,
+		version,
+		chainId,
+		nonce,
+		issuedAt,
+		...tail4
+	});
+}
+/**
+* {@link parse} over raw bytes: size check, strict UTF-8 (`InvalidUtf8`), then parse.
+*
+* @throws {SiwxError}
+*/
+function parseBytes(bytes) {
+	if (bytes.length > 16384) throw new SiwxError({
+		code: "MessageTooLarge",
+		length: bytes.length,
+		max: MAX_MESSAGE_BYTES
+	});
+	const text = utf8Decode(bytes);
+	if (text === void 0) throw syntaxError("InvalidUtf8");
+	return parse(text);
+}
+//#endregion
+//#region src/svm/index.ts
+/**
+* `siwx` Solana (`solana`) namespace profile — SIWS layout plus the off-chain message v1 envelope
+* (sRFC 38).
+*/
+const NAMESPACE = "solana";
+const CHAIN_NAME = "Solana";
+const OFFCHAIN_DOMAIN = new Uint8Array([255, ...utf8Encode("solana offchain")]);
+/** CAIP-2 reference for a Solana `chainId` alias. */
+function chainReference(chainId) {
+	switch (chainId.startsWith("solana:") ? chainId.slice(7) : chainId) {
+		case "mainnet": return "5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp";
+		case "testnet": return "4uhcVJyU9pJkvQyS88uRDiswHXSCkY3z";
+		case "devnet": return "EtWTRABZaYq6iMfeYKouRu166VU2xqa1";
+		case "localnet": return "localnet";
+		default: throw fieldError("chainId", "unknown Solana cluster");
+	}
+}
+function invalidEnvelope() {
+	return syntaxError("InvalidEnvelope");
+}
+/** Decode the v1 envelope at the start of `signed`. */
+function decodeEnvelope(signed) {
+	if (signed.length < 18) throw invalidEnvelope();
+	if ((signed[16] ?? 0) !== 1) throw new SiwxError({
+		code: "Unsupported",
+		reason: "off-chain message version"
+	});
+	if ((signed[17] ?? 0) !== 1) throw invalidEnvelope();
+	const signers = signed.subarray(18, 50);
+	if (signers.length !== 32) throw invalidEnvelope();
+	const content = signed.subarray(50);
+	if (content.length === 0) throw invalidEnvelope();
+	return {
+		signer: signers.subarray(0, 32),
+		content
+	};
+}
+/**
+* Wrap `text` in the off-chain message v1 envelope for `signer` (validated as an SIWS address).
+*
+* @throws {SiwxError} `InvalidField` `address`.
+*/
+function offchainMessage(text, signer) {
+	const signerBytes = addressBytes(signer);
+	canonicalPoint(signerBytes);
+	const textBytes = utf8Encode(text);
+	const out = new Uint8Array(50 + textBytes.length);
+	out.set(OFFCHAIN_DOMAIN, 0);
+	out[16] = 1;
+	out[17] = 1;
+	out.set(signerBytes, 18);
+	out.set(textBytes, 50);
+	return out;
+}
+function svmAccount(message) {
+	validateAddress(message.address);
+	return createAccountId(NAMESPACE, chainReference(message.chainId), message.address);
+}
+/** Create the Solana namespace profile. */
+function svm() {
+	return {
+		namespace: NAMESPACE,
+		label: CHAIN_NAME,
+		account: svmAccount,
+		format(message) {
+			svmAccount(message);
+			return format(message);
+		},
+		parse(signed) {
+			if (signed.length > 16384) throw new SiwxError({
+				code: "MessageTooLarge",
+				length: signed.length,
+				max: MAX_MESSAGE_BYTES
+			});
+			if (signed.length >= OFFCHAIN_DOMAIN.length && equalBytes(signed.subarray(0, OFFCHAIN_DOMAIN.length), OFFCHAIN_DOMAIN)) {
+				const env = decodeEnvelope(signed);
+				const message = parseBytes(env.content);
+				const expected = addressBytes(message.address);
+				if (!equalBytes(env.signer, expected)) throw new SiwxError({
+					code: "Mismatch",
+					field: "address",
+					expected: message.address,
+					actual: b58(env.signer)
+				});
+				return message;
+			}
+			return parseBytes(signed);
+		},
+		verify: async (message, signed, signature) => settle(() => verifyEddsa(message, signed, signature))
+	};
+}
+//#endregion
+export { offchainMessage, siws_exports as siws, svm, validateAddress };

package/package.json

@@ -1,6 +1,86 @@
 {
   "name": "@qntx/siwx",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.7.0",
+  "description": "Sign-In with X (CAIP-122) for TypeScript: SIWE, SIWS, message parsing, validation, and signature verification.",
+  "keywords": [
+    "authentication",
+    "caip-122",
+    "ethereum",
+    "sign-in",
+    "siwe",
+    "siws",
+    "siwx",
+    "solana"
+  ],
+  "homepage": "https://github.com/qntx/siwx#readme",
+  "bugs": {
+    "url": "https://github.com/qntx/siwx/issues"
+  },
+  "license": "MIT OR Apache-2.0",
+  "author": "QuantX <x@qntx.org>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/qntx/siwx.git",
+    "directory": "packages/siwx"
+  },
+  "files": [
+    "dist",
+    "LICENSE-MIT",
+    "LICENSE-APACHE"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs",
+      "default": "./dist/index.mjs"
+    },
+    "./evm": {
+      "types": "./dist/evm.d.mts",
+      "import": "./dist/evm.mjs",
+      "default": "./dist/evm.mjs"
+    },
+    "./svm": {
+      "types": "./dist/svm.d.mts",
+      "import": "./dist/svm.mjs",
+      "default": "./dist/svm.mjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "vp pack",
+    "dev": "vp pack --watch",
+    "test": "vp test",
+    "typecheck": "tsc --noEmit && tsc --noEmit -p tsconfig.src.json",
+    "check:pkg": "vp pack && publint && attw --pack . --profile esm-only",
+    "prepublishOnly": "vp run build",
+    "smoke:hermes": "bun scripts/hermes-smoke.ts"
+  },
+  "dependencies": {
+    "@noble/curves": "^2.4.0",
+    "@noble/hashes": "^2.4.0",
+    "@scure/base": "^2.4.0"
+  },
+  "devDependencies": {
+    "@arethetypeswrong/cli": "0.18.5",
+    "@qntx/tsconfig": "1.0.1",
+    "@types/node": "26.6.5",
+    "publint": "0.3.25",
+    "typescript": "7.0.2",
+    "vite-plus": "1.3.0"
+  },
+  "devEngines": {
+    "packageManager": {
+      "name": "bun",
+      "version": "1.4.0",
+      "onFail": "ignore"
+    }
+  },
+  "engines": {
+    "node": ">=20.19.0"
+  }
+}