bsv-x402 0.1.1 → 0.3.0

package/dist/index.cjs

@@ -20,37 +20,1338 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  BFG_DAILY_CEILING_SATOSHIS: () => BFG_DAILY_CEILING_SATOSHIS,
+  BFG_PER_TX_CEILING_SATOSHIS: () => BFG_PER_TX_CEILING_SATOSHIS,
+  LocalStorageAdapter: () => LocalStorageAdapter,
+  RateLimiter: () => RateLimiter,
+  TIER_PRESETS: () => TIER_PRESETS,
+  WalletTwoFactorProvider: () => WalletTwoFactorProvider,
+  constructBrc105Proof: () => constructBrc105Proof,
+  createX402Fetch: () => createX402Fetch,
+  parseBrc105Challenge: () => parseBrc105Challenge,
   parseChallenge: () => parseChallenge,
+  resolveSitePolicy: () => resolveSitePolicy,
+  resolveSpendLimits: () => resolveSpendLimits,
   x402Fetch: () => x402Fetch
 });
 module.exports = __toCommonJS(index_exports);
 
+// src/brc105-challenge.ts
+function parseBrc105Challenge(response) {
+  const version = response.headers.get("x-bsv-payment-version");
+  if (version === null) {
+    throw new Error("BRC-105: missing x-bsv-payment-version header");
+  }
+  if (version !== "1.0") {
+    throw new Error(`BRC-105: unsupported version "${version}", expected "1.0"`);
+  }
+  const satoshisRaw = response.headers.get("x-bsv-payment-satoshis-required");
+  if (satoshisRaw === null) {
+    throw new Error("BRC-105: missing x-bsv-payment-satoshis-required header");
+  }
+  const satoshisRequired = Number(satoshisRaw);
+  if (!Number.isFinite(satoshisRequired) || !Number.isInteger(satoshisRequired) || satoshisRequired <= 0) {
+    throw new Error("BRC-105: satoshis-required must be a positive integer");
+  }
+  const serverIdentityKey = response.headers.get("x-bsv-auth-identity-key");
+  if (serverIdentityKey === null || serverIdentityKey.length === 0) {
+    throw new Error("BRC-105: missing or empty x-bsv-auth-identity-key header");
+  }
+  if (!/^0[23][0-9a-fA-F]{64}$/.test(serverIdentityKey)) {
+    throw new Error("BRC-105: x-bsv-auth-identity-key must be a 33-byte compressed public key (hex)");
+  }
+  const derivationPrefix = response.headers.get("x-bsv-payment-derivation-prefix");
+  if (derivationPrefix === null || derivationPrefix.length === 0) {
+    throw new Error("BRC-105: missing or empty x-bsv-payment-derivation-prefix header");
+  }
+  return {
+    version,
+    satoshisRequired,
+    serverIdentityKey,
+    derivationPrefix
+  };
+}
+
+// src/brc105-proof.ts
+function bytesToHex(bytes) {
+  return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function hexToBytes(hex) {
+  if (hex.length % 2 !== 0) throw new Error("Hex string must have even length");
+  const bytes = new Uint8Array(hex.length / 2);
+  for (let i = 0; i < hex.length; i += 2) {
+    bytes[i / 2] = parseInt(hex.slice(i, i + 2), 16);
+  }
+  return bytes;
+}
+function bytesToBase64(bytes) {
+  let binary = "";
+  for (const b of bytes) binary += String.fromCharCode(b);
+  return btoa(binary);
+}
+function numberArrayToBase64(arr) {
+  return bytesToBase64(new Uint8Array(arr));
+}
+var RIPEMD160_CONSTANTS = {
+  // Round constants for left and right paths
+  KL: [0, 1518500249, 1859775393, 2400959708, 2840853838],
+  KR: [1352829926, 1548603684, 1836072691, 2053994217, 0],
+  // Message schedule (word index per step)
+  RL: [
+    0,
+    1,
+    2,
+    3,
+    4,
+    5,
+    6,
+    7,
+    8,
+    9,
+    10,
+    11,
+    12,
+    13,
+    14,
+    15,
+    7,
+    4,
+    13,
+    1,
+    10,
+    6,
+    15,
+    3,
+    12,
+    0,
+    9,
+    5,
+    2,
+    14,
+    11,
+    8,
+    3,
+    10,
+    14,
+    4,
+    9,
+    15,
+    8,
+    1,
+    2,
+    7,
+    0,
+    6,
+    13,
+    11,
+    5,
+    12,
+    1,
+    9,
+    11,
+    10,
+    0,
+    8,
+    12,
+    4,
+    13,
+    3,
+    7,
+    15,
+    14,
+    5,
+    6,
+    2,
+    4,
+    0,
+    5,
+    9,
+    7,
+    12,
+    2,
+    10,
+    14,
+    1,
+    3,
+    8,
+    11,
+    6,
+    15,
+    13
+  ],
+  RR: [
+    5,
+    14,
+    7,
+    0,
+    9,
+    2,
+    11,
+    4,
+    13,
+    6,
+    15,
+    8,
+    1,
+    10,
+    3,
+    12,
+    6,
+    11,
+    3,
+    7,
+    0,
+    13,
+    5,
+    10,
+    14,
+    15,
+    8,
+    12,
+    4,
+    9,
+    1,
+    2,
+    15,
+    5,
+    1,
+    3,
+    7,
+    14,
+    6,
+    9,
+    11,
+    8,
+    12,
+    2,
+    10,
+    0,
+    4,
+    13,
+    8,
+    6,
+    4,
+    1,
+    3,
+    11,
+    15,
+    0,
+    5,
+    12,
+    2,
+    13,
+    9,
+    7,
+    10,
+    14,
+    12,
+    15,
+    10,
+    4,
+    1,
+    5,
+    8,
+    7,
+    6,
+    2,
+    13,
+    14,
+    0,
+    3,
+    9,
+    11
+  ],
+  // Rotation amounts
+  SL: [
+    11,
+    14,
+    15,
+    12,
+    5,
+    8,
+    7,
+    9,
+    11,
+    13,
+    14,
+    15,
+    6,
+    7,
+    9,
+    8,
+    7,
+    6,
+    8,
+    13,
+    11,
+    9,
+    7,
+    15,
+    7,
+    12,
+    15,
+    9,
+    11,
+    7,
+    13,
+    12,
+    11,
+    13,
+    6,
+    7,
+    14,
+    9,
+    13,
+    15,
+    14,
+    8,
+    13,
+    6,
+    5,
+    12,
+    7,
+    5,
+    11,
+    12,
+    14,
+    15,
+    14,
+    15,
+    9,
+    8,
+    9,
+    14,
+    5,
+    6,
+    8,
+    6,
+    5,
+    12,
+    9,
+    15,
+    5,
+    11,
+    6,
+    8,
+    13,
+    12,
+    5,
+    12,
+    13,
+    14,
+    11,
+    8,
+    5,
+    6
+  ],
+  SR: [
+    8,
+    9,
+    9,
+    11,
+    13,
+    15,
+    15,
+    5,
+    7,
+    7,
+    8,
+    11,
+    14,
+    14,
+    12,
+    6,
+    9,
+    13,
+    15,
+    7,
+    12,
+    8,
+    9,
+    11,
+    7,
+    7,
+    12,
+    7,
+    6,
+    15,
+    13,
+    11,
+    9,
+    7,
+    15,
+    11,
+    8,
+    6,
+    6,
+    14,
+    12,
+    13,
+    5,
+    14,
+    13,
+    13,
+    7,
+    5,
+    15,
+    5,
+    8,
+    11,
+    14,
+    14,
+    6,
+    14,
+    6,
+    9,
+    12,
+    9,
+    12,
+    5,
+    15,
+    8,
+    8,
+    5,
+    12,
+    9,
+    12,
+    5,
+    14,
+    6,
+    8,
+    13,
+    6,
+    5,
+    15,
+    13,
+    11,
+    11
+  ]
+};
+function rotl32(x, n) {
+  return (x << n | x >>> 32 - n) >>> 0;
+}
+function f(j, x, y, z) {
+  if (j < 16) return (x ^ y ^ z) >>> 0;
+  if (j < 32) return (x & y | ~x & z) >>> 0;
+  if (j < 48) return ((x | ~y) ^ z) >>> 0;
+  if (j < 64) return (x & z | y & ~z) >>> 0;
+  return (x ^ (y | ~z)) >>> 0;
+}
+function ripemd160(message) {
+  const msgLen = message.length;
+  const bitLen = msgLen * 8;
+  const padLen = (55 - msgLen % 64 + 64) % 64 + 1;
+  const padded = new Uint8Array(msgLen + padLen + 8);
+  padded.set(message);
+  padded[msgLen] = 128;
+  const view = new DataView(padded.buffer);
+  view.setUint32(padded.length - 8, bitLen >>> 0, true);
+  view.setUint32(padded.length - 4, bitLen / 4294967296 >>> 0, true);
+  let h0 = 1732584193;
+  let h1 = 4023233417;
+  let h2 = 2562383102;
+  let h3 = 271733878;
+  let h4 = 3285377520;
+  const { KL, KR, RL, RR, SL, SR } = RIPEMD160_CONSTANTS;
+  for (let offset = 0; offset < padded.length; offset += 64) {
+    const w = new Uint32Array(16);
+    for (let i = 0; i < 16; i++) {
+      w[i] = view.getUint32(offset + i * 4, true);
+    }
+    let al = h0, bl = h1, cl = h2, dl = h3, el = h4;
+    let ar = h0, br = h1, cr = h2, dr = h3, er = h4;
+    for (let j = 0; j < 80; j++) {
+      const round = j >>> 4;
+      let t2 = al + f(j, bl, cl, dl) + w[RL[j]] + KL[round] >>> 0;
+      t2 = rotl32(t2, SL[j]) + el >>> 0;
+      al = el;
+      el = dl;
+      dl = rotl32(cl, 10);
+      cl = bl;
+      bl = t2;
+      t2 = ar + f(79 - j, br, cr, dr) + w[RR[j]] + KR[round] >>> 0;
+      t2 = rotl32(t2, SR[j]) + er >>> 0;
+      ar = er;
+      er = dr;
+      dr = rotl32(cr, 10);
+      cr = br;
+      br = t2;
+    }
+    const t = h1 + cl + dr >>> 0;
+    h1 = h2 + dl + er >>> 0;
+    h2 = h3 + el + ar >>> 0;
+    h3 = h4 + al + br >>> 0;
+    h4 = h0 + bl + cr >>> 0;
+    h0 = t;
+  }
+  const digest = new Uint8Array(20);
+  const dv = new DataView(digest.buffer);
+  dv.setUint32(0, h0, true);
+  dv.setUint32(4, h1, true);
+  dv.setUint32(8, h2, true);
+  dv.setUint32(12, h3, true);
+  dv.setUint32(16, h4, true);
+  return digest;
+}
+async function hash160(data) {
+  const sha256 = new Uint8Array(await crypto.subtle.digest("SHA-256", data));
+  return ripemd160(sha256);
+}
+async function pubkeyToP2PKHLockingScript(pubkeyHex) {
+  const pubkeyBytes = hexToBytes(pubkeyHex);
+  const pubkeyHash = await hash160(pubkeyBytes);
+  return `76a914${bytesToHex(pubkeyHash)}88ac`;
+}
+async function createDerivationSuffix(wallet) {
+  const randomBytes = new Uint8Array(16);
+  crypto.getRandomValues(randomBytes);
+  const firstHalf = Array.from(randomBytes);
+  const keyID = new TextDecoder().decode(randomBytes);
+  const { hmac } = await wallet.createHmac({
+    data: firstHalf,
+    protocolID: [2, "server hmac"],
+    keyID,
+    counterparty: "self"
+  });
+  const nonceBytes = [...firstHalf, ...hmac];
+  return numberArrayToBase64(nonceBytes);
+}
+async function constructBrc105Proof(challenge, wallet) {
+  const derivationSuffix = await createDerivationSuffix(wallet);
+  const keyID = `${challenge.derivationPrefix} ${derivationSuffix}`;
+  const { publicKey: derivedPublicKey } = await wallet.getPublicKey({
+    protocolID: [2, "3241645161d8"],
+    keyID,
+    counterparty: challenge.serverIdentityKey
+  });
+  const lockingScript = await pubkeyToP2PKHLockingScript(derivedPublicKey);
+  const result = await wallet.createAction({
+    description: "BRC-105 payment",
+    outputs: [{
+      satoshis: challenge.satoshisRequired,
+      lockingScript,
+      description: "BRC-105 payment output",
+      customInstructions: JSON.stringify({
+        derivationPrefix: challenge.derivationPrefix,
+        derivationSuffix,
+        payee: challenge.serverIdentityKey
+      })
+    }],
+    options: {
+      randomizeOutputs: false
+    }
+  });
+  let transactionBase64;
+  if (result.tx && Array.isArray(result.tx) && result.tx.length > 0) {
+    transactionBase64 = numberArrayToBase64(result.tx);
+  } else if (result.rawTx && typeof result.rawTx === "string" && result.rawTx.length > 0) {
+    transactionBase64 = bytesToBase64(hexToBytes(result.rawTx));
+  } else {
+    throw new Error("Wallet returned no transaction data (neither tx nor rawTx)");
+  }
+  return {
+    derivationPrefix: challenge.derivationPrefix,
+    derivationSuffix,
+    transaction: transactionBase64,
+    txid: result.txid
+  };
+}
+
 // src/challenge.ts
 function parseChallenge(header) {
-  return JSON.parse(header);
+  let parsed;
+  try {
+    parsed = JSON.parse(header);
+  } catch {
+    throw new Error("X402-Challenge: invalid JSON");
+  }
+  if (typeof parsed !== "object" || parsed === null) {
+    throw new Error("X402-Challenge: expected object");
+  }
+  const obj = parsed;
+  if (typeof obj.nonce !== "string" || obj.nonce.length === 0) {
+    throw new Error("X402-Challenge: missing or invalid nonce");
+  }
+  if (typeof obj.payee !== "string" || obj.payee.length === 0) {
+    throw new Error("X402-Challenge: missing or invalid payee");
+  }
+  if (typeof obj.network !== "string" || obj.network.length === 0) {
+    throw new Error("X402-Challenge: missing or invalid network");
+  }
+  if (typeof obj.amount !== "number" || !Number.isFinite(obj.amount) || !Number.isInteger(obj.amount) || obj.amount <= 0) {
+    throw new Error("X402-Challenge: amount must be a positive integer");
+  }
+  return {
+    nonce: obj.nonce,
+    payee: obj.payee,
+    amount: obj.amount,
+    network: obj.network
+  };
+}
+
+// src/limits.ts
+var BFG_DAILY_CEILING_SATOSHIS = 1e10;
+var BFG_PER_TX_CEILING_SATOSHIS = 1e9;
+var WINDOW_MS = {
+  minute: 6e4,
+  hour: 36e5,
+  day: 864e5,
+  week: 6048e5
+};
+function windowToMs(window2) {
+  return WINDOW_MS[window2];
+}
+function makeLimits(windows, perTxMaxSatoshis, opts = {}) {
+  return {
+    windows,
+    perTxMaxSatoshis,
+    yellowLightThreshold: 0.8,
+    requirePerSitePrompt: false,
+    sitePolicies: {},
+    require2fa: {
+      onCircuitBreakerReset: true,
+      onTierChange: true,
+      onHighValueTx: false,
+      highValueThreshold: 0,
+      onNewSiteApproval: false
+    },
+    ...opts
+  };
+}
+var TOO_YOUNG_TO_DIE = {
+  interactive: makeLimits(
+    [{ window: "day", maxSatoshis: 1e8, maxTransactions: Infinity }],
+    1e8
+  ),
+  programmatic: makeLimits(
+    [{ window: "day", maxSatoshis: 1e8, maxTransactions: Infinity }],
+    1e6
+  )
+};
+var HEY_NOT_TOO_ROUGH = {
+  interactive: makeLimits(
+    [
+      { window: "day", maxSatoshis: 1e8, maxTransactions: 100 },
+      { window: "week", maxSatoshis: 5e8, maxTransactions: 500 }
+    ],
+    1e7,
+    {
+      requirePerSitePrompt: true,
+      require2fa: {
+        onCircuitBreakerReset: true,
+        onTierChange: true,
+        onHighValueTx: true,
+        highValueThreshold: 5e7,
+        onNewSiteApproval: true
+      }
+    }
+  ),
+  programmatic: makeLimits(
+    [
+      { window: "day", maxSatoshis: 1e8, maxTransactions: 1e4 },
+      { window: "week", maxSatoshis: 5e8, maxTransactions: 5e4 }
+    ],
+    1e5,
+    {
+      requirePerSitePrompt: true,
+      require2fa: {
+        onCircuitBreakerReset: true,
+        onTierChange: true,
+        onHighValueTx: true,
+        highValueThreshold: 5e7,
+        onNewSiteApproval: true
+      }
+    }
+  )
+};
+var HURT_ME_PLENTY = {
+  interactive: makeLimits(
+    [
+      { window: "minute", maxSatoshis: 5e6, maxTransactions: 10 },
+      { window: "hour", maxSatoshis: 5e7, maxTransactions: 60 },
+      { window: "day", maxSatoshis: 2e8, maxTransactions: 200 },
+      { window: "week", maxSatoshis: 1e9, maxTransactions: 1e3 }
+    ],
+    2e7,
+    {
+      requirePerSitePrompt: true,
+      require2fa: {
+        onCircuitBreakerReset: true,
+        onTierChange: true,
+        onHighValueTx: true,
+        highValueThreshold: 1e8,
+        onNewSiteApproval: true
+      }
+    }
+  ),
+  programmatic: makeLimits(
+    [
+      { window: "minute", maxSatoshis: 5e6, maxTransactions: 1e3 },
+      { window: "hour", maxSatoshis: 5e7, maxTransactions: 6e3 },
+      { window: "day", maxSatoshis: 2e8, maxTransactions: 2e4 },
+      { window: "week", maxSatoshis: 1e9, maxTransactions: 1e5 }
+    ],
+    2e5,
+    {
+      requirePerSitePrompt: true,
+      require2fa: {
+        onCircuitBreakerReset: true,
+        onTierChange: true,
+        onHighValueTx: true,
+        highValueThreshold: 1e8,
+        onNewSiteApproval: true
+      }
+    }
+  )
+};
+var ULTRA_VIOLENCE = {
+  interactive: makeLimits(
+    [...HURT_ME_PLENTY.interactive.windows],
+    HURT_ME_PLENTY.interactive.perTxMaxSatoshis,
+    {
+      requirePerSitePrompt: true,
+      require2fa: {
+        onCircuitBreakerReset: true,
+        onTierChange: true,
+        onHighValueTx: false,
+        highValueThreshold: 0,
+        onNewSiteApproval: true
+      }
+    }
+  ),
+  programmatic: makeLimits(
+    [...HURT_ME_PLENTY.programmatic.windows],
+    HURT_ME_PLENTY.programmatic.perTxMaxSatoshis,
+    {
+      requirePerSitePrompt: true,
+      require2fa: {
+        onCircuitBreakerReset: true,
+        onTierChange: true,
+        onHighValueTx: false,
+        highValueThreshold: 0,
+        onNewSiteApproval: true
+      }
+    }
+  )
+};
+var NIGHTMARE = {
+  interactive: makeLimits([], BFG_PER_TX_CEILING_SATOSHIS),
+  programmatic: makeLimits([], BFG_PER_TX_CEILING_SATOSHIS)
+};
+var TIER_PRESETS = {
+  "I'm Too Young to Die": TOO_YOUNG_TO_DIE,
+  "Hey, Not Too Rough": HEY_NOT_TOO_ROUGH,
+  "Hurt Me Plenty": HURT_ME_PLENTY,
+  "Ultra-Violence": ULTRA_VIOLENCE,
+  "Nightmare!": NIGHTMARE
+};
+function cloneSpendLimits(preset) {
+  return {
+    ...preset,
+    windows: preset.windows.map((w) => ({ ...w })),
+    require2fa: { ...preset.require2fa },
+    sitePolicies: { ...preset.sitePolicies }
+  };
+}
+function resolveSpendLimits(tier = "Hey, Not Too Rough", mode = "interactive", overrides) {
+  const preset = TIER_PRESETS[tier][mode];
+  const base = cloneSpendLimits(preset);
+  if (!overrides) return base;
+  return {
+    ...base,
+    ...overrides,
+    // Deep-merge require2fa if provided
+    require2fa: overrides.require2fa ? { ...base.require2fa, ...overrides.require2fa } : base.require2fa,
+    // Deep-merge sitePolicies if provided
+    sitePolicies: overrides.sitePolicies ? { ...base.sitePolicies, ...overrides.sitePolicies } : base.sitePolicies
+  };
+}
+var RateLimiter = class {
+  constructor(limits, state, now) {
+    this.limits = limits;
+    this.entries = state?.entries ?? [];
+    this.broken = state?.circuitBroken ?? false;
+    this.now = now ?? Date.now;
+  }
+  check(request, origin) {
+    if (this.broken) {
+      return { action: "block", reason: "Circuit breaker tripped \u2014 call resetLimits() to clear", severity: "trip" };
+    }
+    const amount = request.amount;
+    if (!Number.isFinite(amount) || !Number.isInteger(amount) || amount <= 0) {
+      return { action: "block", reason: "Invalid transaction amount rejected", severity: "reject" };
+    }
+    if (amount > BFG_PER_TX_CEILING_SATOSHIS) {
+      return { action: "block", reason: `Exceeds BFG per-tx ceiling (${BFG_PER_TX_CEILING_SATOSHIS} sats)`, severity: "reject" };
+    }
+    const dayAgo = this.now() - WINDOW_MS.day;
+    const dailyTotal = this.sumSatoshis(dayAgo);
+    if (dailyTotal + amount > BFG_DAILY_CEILING_SATOSHIS) {
+      return { action: "block", reason: `Exceeds BFG daily ceiling (${BFG_DAILY_CEILING_SATOSHIS} sats)`, severity: "trip" };
+    }
+    if (amount > this.limits.perTxMaxSatoshis) {
+      return { action: "block", reason: `Exceeds per-tx limit (${this.limits.perTxMaxSatoshis} sats)`, severity: "reject" };
+    }
+    const isCustomSite = this.hasCustomPolicy(origin);
+    const effectiveLimits = this.effectiveWindows(origin);
+    const effectivePerTx = this.effectivePerTxMax(origin);
+    if (effectivePerTx !== void 0 && amount > effectivePerTx) {
+      return { action: "block", reason: `Exceeds per-tx limit for ${origin} (${effectivePerTx} sats)`, severity: "reject" };
+    }
+    let yellowLight;
+    for (const wl of effectiveLimits) {
+      const cutoff = this.now() - windowToMs(wl.window);
+      const windowEntries = this.entriesInWindow(cutoff, isCustomSite ? origin : void 0);
+      const totalSats = windowEntries.reduce((sum, e) => sum + e.satoshis, 0);
+      const totalTx = windowEntries.length;
+      if (totalSats + amount > wl.maxSatoshis) {
+        return { action: "block", reason: `Exceeds ${wl.window} sats limit (${wl.maxSatoshis})`, severity: "window" };
+      }
+      if (totalTx + 1 > wl.maxTransactions) {
+        return { action: "block", reason: `Exceeds ${wl.window} tx count limit (${wl.maxTransactions})`, severity: "window" };
+      }
+      if (this.limits.yellowLightThreshold < 1 && !yellowLight && totalSats + amount > wl.maxSatoshis * this.limits.yellowLightThreshold) {
+        yellowLight = {
+          origin,
+          currentSpend: totalSats,
+          limit: wl.maxSatoshis,
+          window: wl.window,
+          challenge: request
+        };
+      }
+    }
+    if (yellowLight) {
+      return { action: "yellow-light", detail: yellowLight };
+    }
+    return { action: "allow" };
+  }
+  record(entry) {
+    this.entries.push(entry);
+    this.prune();
+  }
+  trip() {
+    this.broken = true;
+  }
+  reset() {
+    this.broken = false;
+  }
+  isBroken() {
+    return this.broken;
+  }
+  getState() {
+    return {
+      entries: [...this.entries],
+      circuitBroken: this.broken,
+      hmac: ""
+    };
+  }
+  hasCustomPolicy(origin) {
+    const policy = this.limits.sitePolicies[origin];
+    return policy?.action === "custom" && !!policy.limits;
+  }
+  effectiveWindows(origin) {
+    const policy = this.limits.sitePolicies[origin];
+    if (policy?.action === "custom" && policy.limits) {
+      return policy.limits;
+    }
+    return this.limits.windows;
+  }
+  effectivePerTxMax(origin) {
+    const policy = this.limits.sitePolicies[origin];
+    if (policy?.action === "custom" && policy.perTxMaxSatoshis !== void 0) {
+      return policy.perTxMaxSatoshis;
+    }
+    return void 0;
+  }
+  entriesInWindow(cutoff, filterOrigin) {
+    return this.entries.filter(
+      (e) => e.timestamp >= cutoff && (filterOrigin === void 0 || e.origin === filterOrigin)
+    );
+  }
+  sumSatoshis(cutoff) {
+    return this.entries.filter((e) => e.timestamp >= cutoff).reduce((sum, e) => sum + e.satoshis, 0);
+  }
+  prune() {
+    let longestWindow = WINDOW_MS.day;
+    for (const wl of this.limits.windows) {
+      longestWindow = Math.max(longestWindow, windowToMs(wl.window));
+    }
+    if (this.limits.sitePolicies) {
+      for (const policy of Object.values(this.limits.sitePolicies)) {
+        if (policy?.action === "custom" && Array.isArray(policy.limits)) {
+          for (const wl of policy.limits) {
+            longestWindow = Math.max(longestWindow, windowToMs(wl.window));
+          }
+        }
+      }
+    }
+    const cutoff = this.now() - longestWindow;
+    this.entries = this.entries.filter((e) => e.timestamp >= cutoff);
+  }
+};
+
+// src/site-policy.ts
+var defaultSitePrompt = async (origin) => {
+  if (typeof globalThis.confirm !== "function") return "global";
+  const allow = globalThis.confirm(
+    `First payment to ${origin}.
+
+Use your global spending limits for this site?
+
+OK = Use global limits
+Cancel = Block this site`
+  );
+  return allow ? "global" : "block";
+};
+async function resolveSitePolicy(origin, limits, twoFactorProvider, promptFn = defaultSitePrompt) {
+  const existing = limits.sitePolicies[origin];
+  if (existing) return existing;
+  if (!limits.requirePerSitePrompt) {
+    return { origin, action: "global" };
+  }
+  if (limits.require2fa.onNewSiteApproval) {
+    if (!twoFactorProvider) {
+      return { origin, action: "block" };
+    }
+    const verified = await twoFactorProvider.verify({
+      type: "new-site-approval",
+      origin
+    });
+    if (!verified) {
+      return { origin, action: "block" };
+    }
+  }
+  const action = await promptFn(origin);
+  return { origin, action };
+}
+
+// src/storage.ts
+var STATE_KEY = "x402:limit-state";
+var POLICIES_KEY = "x402:site-policies";
+async function computeHmac(data, key) {
+  const cryptoKey = await crypto.subtle.importKey(
+    "raw",
+    key,
+    { name: "HMAC", hash: "SHA-256" },
+    false,
+    ["sign"]
+  );
+  const encoded = new TextEncoder().encode(data);
+  const sig = await crypto.subtle.sign("HMAC", cryptoKey, encoded);
+  return Array.from(new Uint8Array(sig)).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function serializeForHmac(state) {
+  return JSON.stringify({
+    entries: state.entries,
+    circuitBroken: state.circuitBroken
+  });
 }
+var LocalStorageAdapter = class {
+  constructor(keyDeriver, storage) {
+    this.keyDeriver = keyDeriver;
+    this.storage = storage ?? globalThis.localStorage;
+  }
+  async load() {
+    const raw = this.storage.getItem(STATE_KEY);
+    if (!raw) return null;
+    let state;
+    try {
+      state = JSON.parse(raw);
+    } catch {
+      console.warn("x402: limit state JSON parse failed \u2014 treating as tampered");
+      return { entries: [], circuitBroken: true, hmac: "" };
+    }
+    if (this.keyDeriver) {
+      if (!state.hmac) {
+        console.warn("x402: limit state missing HMAC \u2014 treating as tampered");
+        return { entries: [], circuitBroken: true, hmac: "" };
+      }
+      const key = await this.keyDeriver();
+      const expected = await computeHmac(serializeForHmac(state), key);
+      if (expected !== state.hmac) {
+        console.warn("x402: limit state HMAC mismatch \u2014 state may have been tampered with");
+        return { entries: [], circuitBroken: true, hmac: "" };
+      }
+    }
+    state.entries = (Array.isArray(state.entries) ? state.entries : []).filter(
+      (e) => e != null && typeof e.origin === "string" && typeof e.txid === "string" && typeof e.satoshis === "number" && Number.isFinite(e.satoshis) && e.satoshis >= 0 && typeof e.timestamp === "number" && Number.isFinite(e.timestamp) && e.timestamp > 0
+    );
+    return state;
+  }
+  async save(state) {
+    if (this.keyDeriver) {
+      const key = await this.keyDeriver();
+      state.hmac = await computeHmac(serializeForHmac(state), key);
+    }
+    this.storage.setItem(STATE_KEY, JSON.stringify(state));
+  }
+  async loadSitePolicies() {
+    const raw = this.storage.getItem(POLICIES_KEY);
+    if (!raw) return {};
+    try {
+      return JSON.parse(raw);
+    } catch {
+      return {};
+    }
+  }
+  async saveSitePolicies(policies) {
+    this.storage.setItem(POLICIES_KEY, JSON.stringify(policies));
+  }
+};
 
 // src/x402-fetch.ts
-async function x402Fetch(input, init) {
-  const response = await fetch(input, init);
-  if (response.status !== 402) {
-    return response;
+var BASE58_ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+function base58DecodeCheck(address) {
+  let leadingZeros = 0;
+  for (const c of address) {
+    if (c === "1") leadingZeros++;
+    else break;
+  }
+  let n = BigInt(0);
+  for (const c of address) {
+    const i = BASE58_ALPHABET.indexOf(c);
+    if (i < 0) throw new Error(`Invalid Base58 character: ${c}`);
+    n = n * 58n + BigInt(i);
+  }
+  const hexFromBigint = n === 0n ? "" : n.toString(16);
+  const paddedHex = hexFromBigint.length % 2 ? "0" + hexFromBigint : hexFromBigint;
+  const bigintBytes = [];
+  for (let i = 0; i < paddedHex.length; i += 2) {
+    bigintBytes.push(parseInt(paddedHex.slice(i, i + 2), 16));
+  }
+  const allBytes = new Uint8Array(leadingZeros + bigintBytes.length);
+  allBytes.set(bigintBytes, leadingZeros);
+  if (allBytes.length !== 25) {
+    throw new Error(`Invalid address length: expected 25 bytes, got ${allBytes.length}`);
   }
-  const challengeHeader = response.headers.get("X402-Challenge");
-  if (!challengeHeader) {
+  const body = allBytes.slice(0, 21);
+  const checksum = allBytes.slice(21);
+  const version = allBytes[0];
+  if (version !== 0 && version !== 111) {
+    throw new Error(`Unsupported address version: 0x${version.toString(16).padStart(2, "0")}`);
+  }
+  return { version, payload: body.slice(1) };
+}
+function payeeAddressToLockingScript(address) {
+  const { payload } = base58DecodeCheck(address);
+  if (payload.length !== 20) {
+    throw new Error(`Invalid pubkey hash length: expected 20 bytes, got ${payload.length}`);
+  }
+  const pubkeyHash = Array.from(payload).map((b) => b.toString(16).padStart(2, "0")).join("");
+  return `76a914${pubkeyHash}88ac`;
+}
+async function defaultConstructProof(challenge) {
+  const cwi = globalThis.CWI;
+  if (!cwi || typeof cwi.createAction !== "function") {
+    throw new Error(
+      "No BRC-100 wallet detected. Install a CWI-compliant browser extension or provide a custom proofConstructor in X402Config."
+    );
+  }
+  const result = await cwi.createAction({
+    description: `x402 payment: ${challenge.amount} sats to ${challenge.payee}`,
+    outputs: [{
+      satoshis: challenge.amount,
+      lockingScript: payeeAddressToLockingScript(challenge.payee),
+      description: `Payment to ${challenge.payee}`
+    }],
+    labels: ["x402-payment"],
+    options: {
+      returnTXIDOnly: false,
+      noSend: false
+    }
+  });
+  if (!result || !result.txid) {
+    throw new Error("Wallet declined payment or returned invalid result");
+  }
+  if (!result.rawTx || typeof result.rawTx !== "string" || result.rawTx.length === 0) {
+    throw new Error("Wallet did not return raw transaction");
+  }
+  return {
+    txid: result.txid,
+    rawTx: result.rawTx
+  };
+}
+function createMutex() {
+  let chain = Promise.resolve();
+  return (fn) => {
+    const result = chain.then(fn, fn);
+    chain = result.then(() => {
+    }, () => {
+    });
+    return result;
+  };
+}
+function createX402Fetch(config = {}) {
+  const tier = config.tier ?? "Hey, Not Too Rough";
+  const mode = config.mode ?? "interactive";
+  if (tier === "Nightmare!" && config.nightmareConfirmation !== "NIGHTMARE") {
+    throw new Error('Nightmare! tier requires nightmareConfirmation: "NIGHTMARE"');
+  }
+  const limits = resolveSpendLimits(tier, mode, config.limits);
+  const storage = config.storage ?? new LocalStorageAdapter();
+  const twoFactor = config.twoFactorProvider;
+  const constructProof = config.proofConstructor ?? defaultConstructProof;
+  const brc105ProofConstructor = config.brc105ProofConstructor;
+  const brc105Wallet = config.brc105Wallet;
+  const nowFn = config.now ?? Date.now;
+  const mutex = createMutex();
+  const needs2fa = limits.require2fa;
+  if (!twoFactor && (needs2fa.onCircuitBreakerReset || needs2fa.onHighValueTx || needs2fa.onNewSiteApproval || needs2fa.onTierChange)) {
+    console.warn("x402: tier requires 2FA but no twoFactorProvider configured \u2014 2FA-gated actions will be blocked");
+  }
+  let limiter;
+  let initialised = false;
+  async function ensureInitialised() {
+    if (limiter && initialised) return limiter;
+    const state = await storage.load();
+    limiter = new RateLimiter(limits, state ?? void 0, nowFn);
+    const policies = await storage.loadSitePolicies();
+    Object.assign(limits.sitePolicies, policies);
+    initialised = true;
+    return limiter;
+  }
+  async function persist(rl) {
+    await storage.save(rl.getState());
+    await storage.saveSitePolicies(limits.sitePolicies);
+  }
+  async function handlePaymentFlow(originalResponse, input, init, origin, amount, protocol, buildProof, retryWithProof, makeLedgerEntry) {
+    return mutex(async () => {
+      const rl = await ensureInitialised();
+      const sitePolicy = await resolveSitePolicy(origin, limits, twoFactor);
+      if (sitePolicy.action === "block") return originalResponse;
+      if (!limits.sitePolicies[origin]) {
+        limits.sitePolicies[origin] = sitePolicy;
+        await storage.saveSitePolicies(limits.sitePolicies);
+      }
+      const spendCheckable = { amount, origin, protocol };
+      const result = rl.check(spendCheckable, origin);
+      if (result.action === "block") {
+        if (result.severity === "trip") {
+          rl.trip();
+          await persist(rl);
+          config.onLimitReached?.(result.reason);
+          return originalResponse;
+        }
+        if (result.severity === "window" && twoFactor) {
+          config.onLimitReached?.(result.reason);
+          const override = await twoFactor.verify({
+            type: "limit-override",
+            amount,
+            origin,
+            reason: result.reason
+          });
+          if (override) {
+          } else {
+            return originalResponse;
+          }
+        } else {
+          config.onLimitReached?.(result.reason);
+          return originalResponse;
+        }
+      }
+      if (result.action === "yellow-light") {
+        const proceed = config.onYellowLight ? await config.onYellowLight(result.detail) : false;
+        if (!proceed) return originalResponse;
+      }
+      if (limits.require2fa.onHighValueTx && amount > limits.require2fa.highValueThreshold) {
+        if (!twoFactor) return originalResponse;
+        const verified = await twoFactor.verify({
+          type: "high-value-tx",
+          amount,
+          origin
+        });
+        if (!verified) return originalResponse;
+      }
+      let proof;
+      try {
+        proof = await buildProof();
+      } catch {
+        return originalResponse;
+      }
+      rl.record(makeLedgerEntry(proof));
+      await persist(rl);
+      return retryWithProof(proof);
+    });
+  }
+  const fetchFn = async function x402Fetch2(input, init) {
+    const response = await fetch(input, init);
+    if (response.status !== 402) return response;
+    const origin = extractOrigin(input);
+    const challengeHeader = response.headers.get("X402-Challenge");
+    if (challengeHeader) {
+      let challenge;
+      try {
+        challenge = parseChallenge(challengeHeader);
+      } catch {
+        return response;
+      }
+      return handlePaymentFlow(
+        response,
+        input,
+        init,
+        origin,
+        challenge.amount,
+        "x402",
+        async () => constructProof(challenge),
+        (proof) => {
+          const headers = new Headers(init?.headers);
+          headers.set("X402-Proof", JSON.stringify(proof));
+          return fetch(input, { ...init, headers });
+        },
+        (proof) => ({
+          timestamp: nowFn(),
+          origin,
+          satoshis: challenge.amount,
+          txid: proof.txid
+        })
+      );
+    }
+    const brc105Version = response.headers.get("x-bsv-payment-version");
+    if (brc105Version) {
+      if (!brc105ProofConstructor && !brc105Wallet) return response;
+      let brc105Challenge;
+      try {
+        brc105Challenge = parseBrc105Challenge(response);
+      } catch {
+        return response;
+      }
+      return handlePaymentFlow(
+        response,
+        input,
+        init,
+        origin,
+        brc105Challenge.satoshisRequired,
+        "brc105",
+        async () => {
+          if (brc105ProofConstructor) {
+            return brc105ProofConstructor(brc105Challenge);
+          }
+          return constructBrc105Proof(brc105Challenge, brc105Wallet);
+        },
+        (proof) => {
+          const headers = new Headers(init?.headers);
+          headers.set("x-bsv-payment", JSON.stringify(proof));
+          return fetch(input, { ...init, headers });
+        },
+        (proof) => ({
+          timestamp: nowFn(),
+          origin,
+          satoshis: brc105Challenge.satoshisRequired,
+          txid: proof.txid,
+          protocol: "brc105"
+        })
+      );
+    }
     return response;
+  };
+  fetchFn.resetLimits = async () => {
+    const rl = await ensureInitialised();
+    if (limits.require2fa.onCircuitBreakerReset) {
+      if (!twoFactor) throw new Error("2FA required for circuit breaker reset but no twoFactorProvider configured");
+      const verified = await twoFactor.verify({ type: "circuit-breaker-reset" });
+      if (!verified) throw new Error("2FA verification failed for circuit breaker reset");
+    }
+    rl.reset();
+    await persist(rl);
+  };
+  fetchFn.getState = () => {
+    if (!limiter) return { entries: [], circuitBroken: false };
+    const state = limiter.getState();
+    return { entries: state.entries, circuitBroken: state.circuitBroken };
+  };
+  return fetchFn;
+}
+var singleton;
+async function x402Fetch(input, init) {
+  if (!singleton) singleton = createX402Fetch();
+  return singleton(input, init);
+}
+function resolveRelativeUrl(url) {
+  const loc = globalThis.location;
+  if (loc?.href) {
+    return new URL(url, loc.href).origin;
+  }
+  return "unknown";
+}
+function extractOrigin(input) {
+  if (input instanceof URL) return input.origin;
+  if (typeof input === "string") {
+    try {
+      return new URL(input).origin;
+    } catch {
+      try {
+        return resolveRelativeUrl(input);
+      } catch {
+        return "unknown";
+      }
+    }
+  }
+  try {
+    return new URL(input.url).origin;
+  } catch {
+    try {
+      return resolveRelativeUrl(input.url);
+    } catch {
+      return "unknown";
+    }
   }
-  const challenge = parseChallenge(challengeHeader);
-  const proof = await constructProof(challenge);
-  const headers = new Headers(init?.headers);
-  headers.set("X402-Proof", JSON.stringify(proof));
-  return fetch(input, { ...init, headers });
 }
-async function constructProof(challenge) {
-  throw new Error("Not implemented \u2014 requires BRC-100 wallet (window.CWI)");
+
+// src/two-factor.ts
+var WalletTwoFactorProvider = class {
+  async verify(action) {
+    if (typeof window === "undefined" || !window.CWI) {
+      return this.promptFallback(action);
+    }
+    const challengeData = `x402-2fa:${JSON.stringify(action)}:${Date.now()}`;
+    try {
+      const sig = await window.CWI.createSignature({
+        data: new TextEncoder().encode(challengeData),
+        protocolID: [1, "x402-2fa"],
+        keyID: "spending-limits"
+      });
+      return sig !== null;
+    } catch {
+      return false;
+    }
+  }
+  promptFallback(action) {
+    if (typeof window === "undefined" || !window.prompt) return false;
+    const message = describeAction(action);
+    const result = window.prompt(`${message}
+
+Type CONFIRM to proceed:`);
+    return result === "CONFIRM";
+  }
+};
+function describeAction(action) {
+  switch (action.type) {
+    case "circuit-breaker-reset":
+      return "Reset spending circuit breaker? This re-enables automated payments.";
+    case "tier-change":
+      return `Change spending tier from "${action.from}" to "${action.to}"?`;
+    case "high-value-tx":
+      return `Approve high-value payment of ${action.amount} sats to ${action.origin}?`;
+    case "new-site-approval":
+      return `Allow automated payments to ${action.origin}?`;
+    case "limit-override":
+      return `Spending limit reached: ${action.reason}
+Allow this payment of ${action.amount} sats to ${action.origin}?`;
+  }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  BFG_DAILY_CEILING_SATOSHIS,
+  BFG_PER_TX_CEILING_SATOSHIS,
+  LocalStorageAdapter,
+  RateLimiter,
+  TIER_PRESETS,
+  WalletTwoFactorProvider,
+  constructBrc105Proof,
+  createX402Fetch,
+  parseBrc105Challenge,
   parseChallenge,
+  resolveSitePolicy,
+  resolveSpendLimits,
   x402Fetch
 });