@bwalletx/connect 0.3.0 → 0.5.0

package/dist/server.d.ts

@@ -1,4 +1,316 @@
-import { WalletProtocol } from '@bsv/sdk';
+import { ChainTracker, WalletProtocol } from '@bsv/sdk';
+import { b as AccessResponse, i as AccessKind, d as ACCESS_PROTOCOL, a as AccessRequirement } from './access-Z6xQwKVF.js';
+export { l as ACCESS_CHALLENGE_LIFETIME_S, c as ACCESS_ERROR_STATUS, e as ACCESS_VERSION, f as AccessChallenge, A as AccessError, g as AccessErrorBody, h as AccessErrorCode, H as HoldingProof, M as MAX_HOLDING_PROOFS, P as PROTOCOL_MEDIA, T as TokenRequirement, j as accessErrorMessage, m as atLeastRaw, k as canonicalJson, n as challengeBytes, o as kindFor, q as normaliseRequirement, r as parseAccessChallenge, p as protocolMediaUrl, t as tokenNeedRaw } from './access-Z6xQwKVF.js';
+
+/**
+ * Shared NonceStore adapters. No database driver is imported: you pass your own client or query
+ * function. Every adapter makes `take` read-and-delete in one step, so each nonce works once.
+ */
+
+/**
+ * The Redis commands used. Fits @upstash/redis and node-redis v4+ as they are
+ * (`set(key, value, { ex | EX })`, `getdel` / `getDel`). For ioredis pass `flavor: 'ioredis'`.
+ */
+interface RedisLike {
+    set(key: string, value: string, ...args: unknown[]): Promise<unknown>;
+    getdel?(key: string): Promise<unknown>;
+    getDel?(key: string): Promise<unknown>;
+}
+interface RedisStoreOptions {
+    client: RedisLike;
+    /** Key prefix. Default 'bwalletx:nonce:'. */
+    prefix?: string;
+    /** 'ioredis' uses positional `set(key, value, 'EX', s)`. Default 'object' (Upstash, node-redis). */
+    flavor?: 'object' | 'ioredis';
+}
+/** Redis / Upstash / Vercel KV. Needs Redis 6.2+ for GETDEL. */
+declare function redisStore(opts: RedisStoreOptions): NonceStore;
+/** `query(sql, params)` resolving to `{ rows }` (node-postgres, @vercel/postgres, Neon) or a bare array (postgres.js `sql.unsafe`). */
+type PgQuery = (sql: string, params: unknown[]) => Promise<{
+    rows: unknown[];
+} | unknown[]>;
+interface PgStoreOptions {
+    query: PgQuery;
+    /** Table name (letters, digits, _ and one optional schema dot). Default 'bwalletx_nonces'. */
+    table?: string;
+}
+/** Run this once (a migration) before using pgStore. */
+declare function pgNonceTableSql(table?: string): string;
+/** Postgres (e.g. self-hosted Supabase). Single-use via DELETE ... RETURNING. */
+declare function pgStore(opts: PgStoreOptions): NonceStore;
+
+/**
+ * Signed session tokens: base64url(JSON payload) + "." + base64url(HMAC-SHA256).
+ * WebCrypto only, so it runs in Node 20+, Vercel Edge and Cloudflare Workers.
+ * There is no default secret: pass one (32+ chars) or every call throws.
+ */
+interface SessionPayload {
+    /** The proven identity key (lowercase hex). */
+    sub: string;
+    /** Issued at, seconds since the epoch. */
+    iat: number;
+    /** Expires at, seconds since the epoch. */
+    exp: number;
+    /** Your app's user id, if the identity key is linked to one. */
+    uid?: string;
+    handle?: string;
+    paymail?: string;
+    [claim: string]: unknown;
+}
+declare const MIN_SECRET_LENGTH = 32;
+interface SignSessionOptions {
+    secret: string;
+    /** Lifetime in seconds. Default 7 days. */
+    maxAge?: number;
+    /** For tests. */
+    now?: number;
+}
+/** Sign a session. `claims.sub` (identity key) is required. */
+declare function signSession(claims: Omit<SessionPayload, 'iat' | 'exp'> & Partial<Pick<SessionPayload, 'iat' | 'exp'>>, opts: SignSessionOptions): Promise<string>;
+/** The payload if the token is authentic and unexpired, else null. Never throws on bad input (only on a missing secret). */
+declare function verifySession(token: unknown, opts: {
+    secret: string;
+    now?: number;
+}): Promise<SessionPayload | null>;
+interface CookieOptions {
+    name: string;
+    maxAge: number;
+    secure?: boolean;
+    sameSite?: 'Lax' | 'Strict' | 'None';
+    path?: string;
+    domain?: string;
+}
+/** A Set-Cookie header value. Always HttpOnly. */
+declare function serializeCookie(value: string, o: CookieOptions): string;
+/** Read one cookie from a Cookie header. */
+declare function readCookie(header: string | null | undefined, name: string): string | null;
+
+/**
+ * Server side: check that a transaction really pays what you expected before you deliver anything.
+ * Read-only: it never broadcasts, signs or retries a spend.
+ */
+
+interface ExpectedOutput {
+    /** Locking script hex. Give this or `address`. */
+    script?: string;
+    /** A P2PKH address. */
+    address?: string;
+    /** Minimum satoshis this output must carry. */
+    satoshis: number;
+}
+type TxStatus = {
+    state: 'confirmed';
+    confirmations: number;
+    source: 'woc' | 'arc';
+} | {
+    state: 'mempool';
+    source: 'woc' | 'arc';
+    detail?: string;
+} | {
+    state: 'not-found' | 'rejected';
+    source: 'woc' | 'arc';
+    detail?: string;
+} | {
+    state: 'unchecked';
+};
+interface VerifyPaymentOptions {
+    /** A txid (fetched from WhatsOnChain), raw tx / BEEF / Atomic BEEF as hex, or BEEF bytes. */
+    tx: string | number[] | Uint8Array;
+    /** Every one must be matched by a different output. */
+    expected: ExpectedOutput[];
+    network?: 'main' | 'test';
+    /** Where to ask for status. Default 'woc'. 'none' skips the network (BEEF only). */
+    status?: 'woc' | 'arc' | 'none';
+    /** ARC base URL, e.g. https://arc.taal.com. Needed when status is 'arc'. */
+    arcUrl?: string;
+    /** Sent as Bearer. Read it from env; never hardcode. */
+    arcApiKey?: string;
+    /** Fail unless the network has seen the tx (mempool or confirmed). Default false. */
+    requireSeen?: boolean;
+    /** Minimum confirmations. Default 0. */
+    minConfirmations?: number;
+    /** Also run SPV (merkle proofs + scripts) on a BEEF with this chain tracker. */
+    spv?: ChainTracker;
+    /** Injected fetch (tests, custom agents). Default globalThis.fetch. */
+    fetch?: typeof fetch;
+}
+interface VerifyPaymentResult {
+    ok: true;
+    txid: string;
+    /** For each expected output, the index of the output that paid it. */
+    matched: {
+        vout: number;
+        satoshis: number;
+        script: string;
+    }[];
+    status: TxStatus;
+}
+type PaymentErrorCode = 'BAD_TX' | 'TX_NOT_FOUND' | 'OUTPUT_MISSING' | 'NOT_SEEN' | 'REJECTED' | 'SPV_FAILED' | 'NETWORK' | 'BAD_EXPECTED';
+declare class PaymentVerificationError extends Error {
+    readonly code: PaymentErrorCode;
+    readonly txid?: string | undefined;
+    constructor(code: PaymentErrorCode, message: string, txid?: string | undefined);
+}
+/**
+ * Throws PaymentVerificationError (with a `code`) unless every expected output is paid by a
+ * distinct output of the transaction with at least the expected satoshis.
+ */
+declare function verifyPayment(o: VerifyPaymentOptions): Promise<VerifyPaymentResult>;
+
+/**
+ * Link a proven identity key to a user in YOUR auth system (Supabase, next-auth, your own table).
+ * You supply the storage callbacks; this module only holds the rules.
+ */
+interface LinkCallbacks {
+    /** The user id this identity key is linked to, or null. */
+    findUserByIdentityKey(identityKey: string): Promise<string | null> | string | null;
+    /** Save the link. Make (identity_key) unique in your table so a race cannot double-link. */
+    attach(userId: string, identityKey: string): Promise<void> | void;
+}
+type LinkResult = {
+    status: 'linked' | 'already-linked';
+    userId: string;
+    identityKey: string;
+};
+declare class IdentityLinkConflictError extends Error {
+    readonly identityKey: string;
+    readonly otherUserId: string;
+    readonly code = "IDENTITY_LINKED_TO_OTHER_USER";
+    constructor(identityKey: string, otherUserId: string);
+}
+/**
+ * Link `identityKey` (already verified with verifySignIn) to the signed-in `userId`.
+ * Throws IdentityLinkConflictError if it belongs to someone else. Idempotent for the same user.
+ */
+declare function linkIdentity(userId: string, identityKey: string, cb: LinkCallbacks): Promise<LinkResult>;
+interface SignInOrLinkOptions extends LinkCallbacks {
+    /** The user already signed in some other way (e.g. HandCash, email), if any. */
+    currentUserId?: string | null;
+    /** Make a new user for an unknown identity key. Without it, unknown keys return status 'unknown'. */
+    createUser?(identityKey: string): Promise<string> | string;
+}
+type SignInOrLinkResult = {
+    status: 'signed-in' | 'linked' | 'already-linked' | 'created';
+    userId: string;
+    identityKey: string;
+} | {
+    status: 'unknown';
+    userId: null;
+    identityKey: string;
+};
+/**
+ * The usual verify-route logic: signed in already → link; known key → that user; else create (or report unknown).
+ * Throws IdentityLinkConflictError when a signed-in user tries to link a key owned by another user.
+ */
+declare function signInOrLink(identityKey: string, o: SignInOrLinkOptions): Promise<SignInOrLinkResult>;
+
+interface IdentityStatus {
+    /** bit-sign identity level: 0 none, 1 Basic … 4 Sovereign (Veriff). */
+    level: number;
+    /** A live KYC credential for this identity key. */
+    kyc: boolean;
+}
+/**
+ * Where verifyAccess reads the chain and identity data. Every method THROWS when it cannot answer;
+ * a throw becomes `indexer_unavailable`, never "holds nothing".
+ */
+interface AccessResolver {
+    /** Confirmed + unspent raw balance of `tokenId` ('bsv21:…') over these P2PKH addresses. */
+    tokenBalance(tokenId: string, addresses: string[]): Promise<string>;
+    /** Total supply, raw. Needed only for minBps requirements. */
+    tokenSupply?(tokenId: string): Promise<string>;
+    /** Identity level and KYC for a key. Needed only for identityLevel / kyc requirements. */
+    identity?(identityKey: string, response: AccessResponse): Promise<IdentityStatus>;
+}
+type FetchLike = typeof fetch;
+interface OneSatResolverOptions {
+    /** Default 'https://api.1sat.app/1sat'. */
+    base?: string;
+    fetch?: FetchLike;
+    timeoutMs?: number;
+}
+/** BSV-21 balances and supply from the 1Sat indexer (the one bit-sign's token rooms use). */
+declare function oneSatResolver(o?: OneSatResolverOptions): AccessResolver;
+interface BitSignResolverOptions {
+    /** Default 'https://bit-sign.online'. */
+    base?: string;
+    fetch?: FetchLike;
+    timeoutMs?: number;
+    /** Token reads. Default: oneSatResolver(). */
+    tokens?: AccessResolver;
+}
+/**
+ * Identity level / KYC from bit-sign's POST /api/access/verify, which checks the signed response
+ * itself (the user's signature is their consent to disclose those facts to this origin).
+ * Token reads go to `tokens` (default the 1Sat indexer).
+ */
+declare function bitSignResolver(o?: BitSignResolverOptions): AccessResolver;
+interface CreateAccessChallengeOptions {
+    /** YOUR origin from config. Never from the request. */
+    origin: string;
+    /** The requirement, from YOUR config. Never from the request. */
+    require: AccessRequirement;
+    /** A shared store (redisStore / pgStore). The same stores sign-in uses. */
+    store: NonceStore;
+    /** The identity key the browser says it is (optional). If given, a different signer is wrong_account. */
+    identityKey?: unknown;
+    /** Default: '403' when a token is required, else '401'. */
+    kind?: AccessKind;
+    lifetimeS?: number;
+    now?: number;
+}
+interface AccessChallengeResponse {
+    /** The canonical JSON the wallet signs. Pass it to the wallet unchanged. */
+    challenge: string;
+    nonce: string;
+    kind: AccessKind;
+    protocolID: typeof ACCESS_PROTOCOL;
+    keyID: string;
+    exp: number;
+}
+declare function createAccessChallenge(o: CreateAccessChallengeOptions): Promise<AccessChallengeResponse>;
+/** The P2PKH address a holding proof establishes, or null if the proof does not verify. */
+declare function verifyHoldingProof(challenge: string, p: unknown): string | null;
+interface VerifyAccessOptions {
+    origin: string;
+    /** The body the browser posted (AccessResponse). Untrusted. */
+    response: unknown;
+    store: NonceStore;
+    resolver: AccessResolver;
+    /**
+     * The requirement YOUR config says this gate needs. If given, the challenge must carry exactly it
+     * (defence in depth: the challenge came from your store, but configs change).
+     */
+    require?: AccessRequirement;
+    now?: number;
+}
+interface AccessGrant {
+    ok: true;
+    identityKey: string;
+    kind: AccessKind;
+    require: AccessRequirement;
+    /** Proven addresses holding the token (store them to re-check later). */
+    addresses: string[];
+    have: {
+        tokenRaw?: string;
+        needRaw?: string;
+        identityLevel?: number;
+        kyc?: boolean;
+    };
+}
+/**
+ * Verify a wallet's response. Returns the grant, or throws AccessError with a protocol code.
+ * The nonce is consumed first, so each challenge can be tried once.
+ */
+declare function verifyAccess(o: VerifyAccessOptions): Promise<AccessGrant>;
+/**
+ * Re-check a token requirement over already-proven addresses (for periodic re-verification).
+ * Returns { have, need } or throws AccessError('insufficient_tokens' | 'indexer_unavailable').
+ */
+declare function checkTokenHolding(require: AccessRequirement, addresses: string[], resolver: AccessResolver): Promise<{
+    have: string;
+    need: string;
+}>;
 
 /** Security level 2, a protocol name used for nothing else. Keep it constant. */
 declare const LOGIN_PROTOCOL: WalletProtocol;
@@ -61,4 +373,4 @@ declare function verifySignIn(opts: VerifySignInOptions): Promise<string | null>
 /** True when a request's Origin header is exactly your configured origin. Check it on both routes. */
 declare function originAllowed(requestOrigin: string | null | undefined, origin: string): boolean;
 
-export { CHALLENGE_LIFETIME_MS, type ChallengeResponse, type CreateChallengeOptions, LOGIN_PROTOCOL, type NonceStore, type PendingChallenge, type VerifySignInOptions, createChallenge, isIdentityKey, loginMessage, memoryStore, originAllowed, verifySignIn };
+export { ACCESS_PROTOCOL, type AccessChallengeResponse, type AccessGrant, AccessKind, AccessRequirement, type AccessResolver, AccessResponse, type BitSignResolverOptions, CHALLENGE_LIFETIME_MS, type ChallengeResponse, type CookieOptions, type CreateAccessChallengeOptions, type CreateChallengeOptions, type ExpectedOutput, IdentityLinkConflictError, type IdentityStatus, LOGIN_PROTOCOL, type LinkCallbacks, type LinkResult, MIN_SECRET_LENGTH, type NonceStore, type OneSatResolverOptions, PaymentVerificationError, type PendingChallenge, type PgQuery, type PgStoreOptions, type RedisLike, type RedisStoreOptions, type SessionPayload, type SignInOrLinkOptions, type SignInOrLinkResult, type SignSessionOptions, type TxStatus, type VerifyAccessOptions, type VerifyPaymentOptions, type VerifyPaymentResult, type VerifySignInOptions, bitSignResolver, checkTokenHolding, createAccessChallenge, createChallenge, isIdentityKey, linkIdentity, loginMessage, memoryStore, oneSatResolver, originAllowed, pgNonceTableSql, pgStore, readCookie, redisStore, serializeCookie, signInOrLink, signSession, verifyAccess, verifyHoldingProof, verifyPayment, verifySession, verifySignIn };

package/dist/server.js

@@ -1,118 +1,93 @@
-// src/server.ts
-import { ProtoWallet, PublicKey } from "@bsv/sdk";
-var LOGIN_PROTOCOL = [2, "bwallet sign in"];
-var CHALLENGE_LIFETIME_MS = 2 * 60 * 1e3;
-var warned = false;
-function memoryStore(opts = {}) {
-  if (!opts.quiet && !warned) {
-    warned = true;
-    console.warn("[@bwalletx/connect] Using the in-memory nonce store. It is for development only; pass a shared store (Redis, database) in production.");
-  }
-  const m = /* @__PURE__ */ new Map();
-  return {
-    put(nonce, c) {
-      const now = Date.now();
-      for (const [k, v] of m) if (v.expiresAt < now) m.delete(k);
-      m.set(nonce, c);
-    },
-    take(nonce) {
-      const c = m.get(nonce) ?? null;
-      m.delete(nonce);
-      return c;
-    }
-  };
-}
-var defaultStore = null;
-var storeOrDefault = (s) => s ?? (defaultStore ??= memoryStore());
-function isIdentityKey(x) {
-  if (typeof x !== "string" || !/^0[23][0-9a-fA-F]{64}$/.test(x)) return false;
-  try {
-    PublicKey.fromString(x);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function normalOrigin(origin) {
-  const u = new URL(origin);
-  if (u.origin === "null" || u.origin !== origin.replace(/\/$/, "")) {
-    throw new Error(`origin must be scheme://host[:port], got ${origin}`);
-  }
-  return u.origin;
-}
-function loginMessage(origin, nonce, expiresAt) {
-  return [
-    `Sign in to ${new URL(origin).host} with bWallet`,
-    "",
-    "This proves you hold this wallet. It does not spend anything.",
-    "",
-    `Origin: ${origin}`,
-    `Nonce: ${nonce}`,
-    `Expires: ${new Date(expiresAt).toISOString()}`
-  ].join("\n");
-}
-function randomNonce() {
-  const b = new Uint8Array(16);
-  globalThis.crypto.getRandomValues(b);
-  let s = "";
-  for (const x of b) s += String.fromCharCode(x);
-  return btoa(s).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
-}
-async function createChallenge(opts) {
-  if (!isIdentityKey(opts.identityKey)) throw new Error("identityKey must be a compressed public key (66 hex chars)");
-  const origin = normalOrigin(opts.origin);
-  const nonce = randomNonce();
-  const expiresAt = Date.now() + CHALLENGE_LIFETIME_MS;
-  const message = loginMessage(origin, nonce, expiresAt);
-  await storeOrDefault(opts.store).put(nonce, { identityKey: opts.identityKey.toLowerCase(), origin, message, expiresAt });
-  return { nonce, message, protocolID: LOGIN_PROTOCOL, keyID: nonce, expiresAt };
-}
-async function verifySignIn(opts) {
-  if (typeof opts.nonce !== "string" || opts.nonce.length > 64) return null;
-  const c = await storeOrDefault(opts.store).take(opts.nonce);
-  if (!c || Date.now() > c.expiresAt) return null;
-  let origin;
-  try {
-    origin = normalOrigin(opts.origin);
-  } catch {
-    return null;
-  }
-  if (c.origin !== origin) return null;
-  if (!isIdentityKey(opts.identityKey)) return null;
-  const identityKey = opts.identityKey.toLowerCase();
-  if (c.identityKey !== identityKey) return null;
-  const sig = opts.signature;
-  if (!Array.isArray(sig) || sig.length < 8 || sig.length > 80 || !sig.every((b) => Number.isInteger(b) && b >= 0 && b <= 255)) {
-    return null;
-  }
-  try {
-    const { valid } = await new ProtoWallet("anyone").verifySignature({
-      protocolID: LOGIN_PROTOCOL,
-      keyID: opts.nonce,
-      counterparty: identityKey,
-      data: Array.from(new TextEncoder().encode(c.message)),
-      signature: sig
-    });
-    return valid ? identityKey : null;
-  } catch {
-    return null;
-  }
-}
-function originAllowed(requestOrigin, origin) {
-  try {
-    return !!requestOrigin && requestOrigin === normalOrigin(origin);
-  } catch {
-    return false;
-  }
-}
+import {
+  CHALLENGE_LIFETIME_MS,
+  IdentityLinkConflictError,
+  LOGIN_PROTOCOL,
+  MIN_SECRET_LENGTH,
+  PaymentVerificationError,
+  bitSignResolver,
+  checkTokenHolding,
+  createAccessChallenge,
+  createChallenge,
+  isIdentityKey,
+  linkIdentity,
+  loginMessage,
+  memoryStore,
+  oneSatResolver,
+  originAllowed,
+  pgNonceTableSql,
+  pgStore,
+  readCookie,
+  redisStore,
+  serializeCookie,
+  signInOrLink,
+  signSession,
+  verifyAccess,
+  verifyHoldingProof,
+  verifyPayment,
+  verifySession,
+  verifySignIn
+} from "./chunk-QRXFL66W.js";
+import {
+  ACCESS_CHALLENGE_LIFETIME_S,
+  ACCESS_ERROR_STATUS,
+  ACCESS_PROTOCOL,
+  ACCESS_VERSION,
+  AccessError,
+  MAX_HOLDING_PROOFS,
+  PROTOCOL_MEDIA,
+  accessErrorMessage,
+  atLeastRaw,
+  canonicalJson,
+  challengeBytes,
+  kindFor,
+  normaliseRequirement,
+  parseAccessChallenge,
+  protocolMediaUrl,
+  tokenNeedRaw
+} from "./chunk-MWD4BCO5.js";
 export {
+  ACCESS_CHALLENGE_LIFETIME_S,
+  ACCESS_ERROR_STATUS,
+  ACCESS_PROTOCOL,
+  ACCESS_VERSION,
+  AccessError,
   CHALLENGE_LIFETIME_MS,
+  IdentityLinkConflictError,
   LOGIN_PROTOCOL,
+  MAX_HOLDING_PROOFS,
+  MIN_SECRET_LENGTH,
+  PROTOCOL_MEDIA,
+  PaymentVerificationError,
+  accessErrorMessage,
+  atLeastRaw,
+  bitSignResolver,
+  canonicalJson,
+  challengeBytes,
+  checkTokenHolding,
+  createAccessChallenge,
   createChallenge,
   isIdentityKey,
+  kindFor,
+  linkIdentity,
   loginMessage,
   memoryStore,
+  normaliseRequirement,
+  oneSatResolver,
   originAllowed,
+  parseAccessChallenge,
+  pgNonceTableSql,
+  pgStore,
+  protocolMediaUrl,
+  readCookie,
+  redisStore,
+  serializeCookie,
+  signInOrLink,
+  signSession,
+  tokenNeedRaw,
+  verifyAccess,
+  verifyHoldingProof,
+  verifyPayment,
+  verifySession,
   verifySignIn
 };
 //# sourceMappingURL=server.js.map

package/dist/server.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/server.ts"],"sourcesContent":["import { ProtoWallet, PublicKey, type WalletProtocol } from '@bsv/sdk';\n\n/** Security level 2, a protocol name used for nothing else. Keep it constant. */\nexport const LOGIN_PROTOCOL: WalletProtocol = [2, 'bwallet sign in'];\nexport const CHALLENGE_LIFETIME_MS = 2 * 60 * 1000;\n\nexport interface PendingChallenge {\n  identityKey: string;\n  origin: string;\n  message: string;\n  expiresAt: number;\n}\n\n/**\n * Where challenges wait between the two routes. Use Redis or a database table in production.\n * `take` must read and delete in one step, so each nonce can be tried once.\n */\nexport interface NonceStore {\n  put(nonce: string, c: PendingChallenge): Promise<void> | void;\n  take(nonce: string): Promise<PendingChallenge | null> | PendingChallenge | null;\n}\n\nlet warned = false;\n\n/**\n * In-memory store. For development and tests only: it is lost on restart and not shared between\n * server processes or serverless instances. Expired entries are pruned on each put.\n */\nexport function memoryStore(opts: { quiet?: boolean } = {}): NonceStore {\n  if (!opts.quiet && !warned) {\n    warned = true;\n    console.warn('[@bwalletx/connect] Using the in-memory nonce store. It is for development only; pass a shared store (Redis, database) in production.');\n  }\n  const m = new Map<string, PendingChallenge>();\n  return {\n    put(nonce, c) {\n      const now = Date.now();\n      for (const [k, v] of m) if (v.expiresAt < now) m.delete(k);\n      m.set(nonce, c);\n    },\n    take(nonce) {\n      const c = m.get(nonce) ?? null;\n      m.delete(nonce);\n      return c;\n    },\n  };\n}\n\nlet defaultStore: NonceStore | null = null;\nconst storeOrDefault = (s?: NonceStore) => s ?? (defaultStore ??= memoryStore());\n\nexport function isIdentityKey(x: unknown): x is string {\n  if (typeof x !== 'string' || !/^0[23][0-9a-fA-F]{64}$/.test(x)) return false;\n  try {\n    PublicKey.fromString(x);\n    return true;\n  } catch {\n    return false;\n  }\n}\n\nfunction normalOrigin(origin: string): string {\n  const u = new URL(origin);\n  if (u.origin === 'null' || u.origin !== origin.replace(/\\/$/, '')) {\n    throw new Error(`origin must be scheme://host[:port], got ${origin}`);\n  }\n  return u.origin;\n}\n\n/** The text the user signs. Lines joined with \\n, no trailing newline. */\nexport function loginMessage(origin: string, nonce: string, expiresAt: number): string {\n  return [\n    `Sign in to ${new URL(origin).host} with bWallet`,\n    '',\n    'This proves you hold this wallet. It does not spend anything.',\n    '',\n    `Origin: ${origin}`,\n    `Nonce: ${nonce}`,\n    `Expires: ${new Date(expiresAt).toISOString()}`,\n  ].join('\\n');\n}\n\nfunction randomNonce(): string {\n  const b = new Uint8Array(16);\n  globalThis.crypto.getRandomValues(b);\n  let s = '';\n  for (const x of b) s += String.fromCharCode(x);\n  return btoa(s).replace(/\\+/g, '-').replace(/\\//g, '_').replace(/=+$/, '');\n}\n\nexport interface CreateChallengeOptions {\n  /** YOUR site's origin from config, e.g. \"https://example.com\". Never take it from the request. */\n  origin: string;\n  /** The identity key the browser claims. Checked again at verify. */\n  identityKey: unknown;\n  /** Default: a process-wide in-memory store (dev only). */\n  store?: NonceStore;\n}\n\nexport interface ChallengeResponse {\n  nonce: string;\n  message: string;\n  protocolID: WalletProtocol;\n  keyID: string;\n  expiresAt: number;\n}\n\n/** Step 1. Throws if identityKey is not a valid compressed public key. Send the result to the browser. */\nexport async function createChallenge(opts: CreateChallengeOptions): Promise<ChallengeResponse> {\n  if (!isIdentityKey(opts.identityKey)) throw new Error('identityKey must be a compressed public key (66 hex chars)');\n  const origin = normalOrigin(opts.origin);\n  const nonce = randomNonce();\n  const expiresAt = Date.now() + CHALLENGE_LIFETIME_MS;\n  const message = loginMessage(origin, nonce, expiresAt);\n  await storeOrDefault(opts.store).put(nonce, { identityKey: opts.identityKey.toLowerCase(), origin, message, expiresAt });\n  return { nonce, message, protocolID: LOGIN_PROTOCOL, keyID: nonce, expiresAt };\n}\n\nexport interface VerifySignInOptions {\n  /** YOUR site's origin from config. Must equal the origin the challenge was made for. */\n  origin: string;\n  /** From the request body. */\n  identityKey: unknown;\n  nonce: unknown;\n  signature: unknown;\n  store?: NonceStore;\n}\n\n/**\n * Step 2. Returns the proven identity key (lowercase hex), or null.\n * The nonce is deleted before anything is checked, so each challenge can be tried once.\n */\nexport async function verifySignIn(opts: VerifySignInOptions): Promise<string | null> {\n  if (typeof opts.nonce !== 'string' || opts.nonce.length > 64) return null;\n  const c = await storeOrDefault(opts.store).take(opts.nonce);\n  if (!c || Date.now() > c.expiresAt) return null;\n  let origin: string;\n  try {\n    origin = normalOrigin(opts.origin);\n  } catch {\n    return null;\n  }\n  if (c.origin !== origin) return null;\n  if (!isIdentityKey(opts.identityKey)) return null;\n  const identityKey = opts.identityKey.toLowerCase();\n  if (c.identityKey !== identityKey) return null;\n\n  const sig = opts.signature;\n  if (!Array.isArray(sig) || sig.length < 8 || sig.length > 80 || !sig.every((b) => Number.isInteger(b) && b >= 0 && b <= 255)) {\n    return null;\n  }\n  try {\n    const { valid } = await new ProtoWallet('anyone').verifySignature({\n      protocolID: LOGIN_PROTOCOL,\n      keyID: opts.nonce,\n      counterparty: identityKey,\n      data: Array.from(new TextEncoder().encode(c.message)),\n      signature: sig as number[],\n    });\n    return valid ? identityKey : null;\n  } catch {\n    return null; // @bsv/sdk throws on a bad signature instead of returning valid: false\n  }\n}\n\n/** True when a request's Origin header is exactly your configured origin. Check it on both routes. */\nexport function originAllowed(requestOrigin: string | null | undefined, origin: string): boolean {\n  try {\n    return !!requestOrigin && requestOrigin === normalOrigin(origin);\n  } catch {\n    return false;\n  }\n}\n"],"mappings":"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","names":[]}
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}