From 69997b1cf47470bbe098ca042b5b64ef5e8873e6 Mon Sep 17 00:00:00 2001 From: Adam Soltys Date: Thu, 19 Nov 2026 21:53:03 -0700 Subject: A browser extension that signs for nostr sites without asking twice, and pays from a Coinos wallet. "I'm using Sidecar right now, and I don't like how I have to reauthorize it. It prompts me too much. I just want it to automatically sign all the time with my key" (Adam, 2026-11-19). The extension (extension/, Chrome, Manifest V3) gives every page window.nostr (NIP-07: getPublicKey, signEvent, nip04, nip44) and window.webln. A site is asked once: "Always allow" is remembered with no expiry until the site is removed in the popup, "Never for this site" blocks it, and closing the window refuses that one call. Signing and paying are separate permissions. The key is an nsec or a wallet's twelve words (NIP-06), kept in the extension's storage unencrypted so it can sign without a prompt. The wallet is the person's own Coinos wallet over Nostr Wallet Connect: the extension holds a connection string, the wallet enforces that connection's budget, and the popup shows the balance and recent payments. Build with `bun extension/build.js` and load extension/dist unpacked. New extension-test loads the built extension into Chrome with its own relay and wallet service and passes (28 checks). Co-Authored-By: Claude Fable 5.2 Claude-Session: https://claude.ai/code/session_01VMan6WFVA5qCuTtny8PRL6 --- extension/src/background.js | 305 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 305 insertions(+) create mode 100644 extension/src/background.js (limited to 'extension/src/background.js') diff --git a/extension/src/background.js b/extension/src/background.js new file mode 100644 index 0000000..dcefa18 --- /dev/null +++ b/extension/src/background.js @@ -0,0 +1,305 @@ +// The extension's background worker. It holds the nostr key and the wallet +// connection, decides which sites may use them, and answers the calls a +// page makes through window.nostr and window.webln. +// +// A site is asked about once: "Always allow" is remembered for good (until +// the site is removed in the popup), so signing never prompts again. Signing +// and paying are separate permissions. +// +// The wallet is the person's Coinos wallet, reached over Nostr Wallet Connect +// (NIP-47): the extension holds a connection string, never the wallet's keys, +// and the wallet enforces that connection's budget. + +import { finalizeEvent, getPublicKey, nip04, nip19, nip44 } from 'nostr-tools'; +import { Relay } from 'nostr-tools/relay'; +import { HDKey } from '@scure/bip32'; +import { mnemonicToSeedSync, validateMnemonic } from '@scure/bip39'; +import { wordlist } from '@scure/bip39/wordlists/english.js'; +import { bytesToHex, hexToBytes } from '@noble/hashes/utils.js'; + +const store = { + get: async (k) => (await chrome.storage.local.get(k))[k], + set: (k, v) => chrome.storage.local.set({ [k]: v }), + del: (k) => chrome.storage.local.remove(k), +}; + +// ── the key ──────────────────────────────────────────────────────────────── +// Kept in the extension's own storage, unencrypted: signing without a prompt +// means the key has to be readable whenever a site asks. No page can read it. +async function secretKey() { + const k = await store.get('key'); + if (!k || !k.sk) throw new Error('The Coinos extension has no key yet. Click its icon to set it up.'); + return hexToBytes(k.sk); +} + +// "nsec1…", 64 hex characters, or twelve/twenty-four words (NIP-06, the key +// Coinos derives for a wallet: m/44'/1237'/0'/0/0). +function parseKey(input) { + const s = String(input || '').trim(); + if (/^nsec1/i.test(s)) { + const d = nip19.decode(s.toLowerCase()); + if (d.type !== 'nsec') throw new Error('That is not an nsec'); + return { sk: bytesToHex(d.data), source: 'nsec' }; + } + if (/^[0-9a-f]{64}$/i.test(s)) return { sk: s.toLowerCase(), source: 'hex' }; + const words = s.toLowerCase().split(/\s+/).join(' '); + if (validateMnemonic(words, wordlist)) { + const sk = HDKey.fromMasterSeed(mnemonicToSeedSync(words)).derive("m/44'/1237'/0'/0/0").privateKey; + return { sk: bytesToHex(sk), source: 'seed' }; + } + throw new Error('Enter an nsec, or the twelve words of a Coinos wallet'); +} + +// ── sites ────────────────────────────────────────────────────────────────── +// sites[origin] = { sign: true|false, pay: true|false, at } — true is "always +// allow", false is "never", absent means ask. +const sitesOf = async () => (await store.get('sites')) || {}; + +const asks = new Map(); // `${origin} ${kind}` → { promise, resolve, reject, windowId } +let askSeq = 0; + +// A worker with nothing to do is stopped after 30 s; one waiting on a prompt +// or on the wallet has to stay. Any extension API call resets that clock. +let busy = 0; +let beat = null; +function hold() { + busy++; + if (!beat) beat = setInterval(() => { chrome.runtime.getPlatformInfo(() => {}); }, 20_000); + return () => { if (--busy <= 0) { busy = 0; clearInterval(beat); beat = null; } }; +} + +async function allowed(origin, kind) { + const site = (await sitesOf())[origin]; + if (site && site[kind] === true) return; + if (site && site[kind] === false) throw new Error('This site is blocked in the Coinos extension'); + const key = `${origin} ${kind}`; + let ask = asks.get(key); + if (!ask) { + ask = { id: `${Date.now().toString(36)}${++askSeq}` }; + ask.promise = new Promise((resolve, reject) => { ask.resolve = resolve; ask.reject = reject; }); + asks.set(key, ask); + const release = hold(); + ask.promise.catch(() => {}).finally(() => { asks.delete(key); release(); }); + const url = chrome.runtime.getURL(`prompt.html?id=${ask.id}&kind=${kind}&origin=${encodeURIComponent(origin)}`); + try { + const w = await chrome.windows.create({ url, type: 'popup', width: 400, height: 330, focused: true }); + ask.windowId = w.id; + } catch (err) { + ask.reject(new Error('Could not open the approval window')); + } + } + return ask.promise; +} + +// the prompt closed without an answer: this request is refused, the site is +// asked again next time +chrome.windows.onRemoved.addListener((windowId) => { + for (const ask of asks.values()) if (ask.windowId === windowId) ask.reject(new Error('Request was dismissed')); +}); + +async function answerAsk({ id, origin, kind, choice }) { + const ask = [...asks.values()].find((a) => a.id === id); + if (choice === 'always' || choice === 'never') { + const sites = await sitesOf(); + sites[origin] = { ...(sites[origin] || {}), [kind]: choice === 'always', at: Date.now() }; + await store.set('sites', sites); + } + if (!ask) return; + if (choice === 'always') ask.resolve(); + else ask.reject(new Error(choice === 'never' ? 'This site is blocked in the Coinos extension' : 'Request was denied')); +} + +// ── the wallet (NIP-47 client) ───────────────────────────────────────────── +function parseNwc(uri) { + const s = String(uri || '').trim(); + if (!/^nostr\+walletconnect:/i.test(s)) throw new Error('Paste a connection string that starts with nostr+walletconnect://'); + const u = new URL(s.replace(/^nostr\+walletconnect:(\/\/)?/i, 'http://')); + const walletPk = u.hostname.toLowerCase(); + const secret = (u.searchParams.get('secret') || '').toLowerCase(); + const relays = u.searchParams.getAll('relay').filter((r) => /^wss?:\/\//.test(r)); + if (!/^[0-9a-f]{64}$/.test(walletPk) || !/^[0-9a-f]{64}$/.test(secret) || !relays.length) throw new Error('That connection string is incomplete'); + return { walletPk, secret, relays }; +} + +// One request, one answer. The request goes to every relay in the connection +// and the first reply wins; a relay that is down is skipped. +async function wallet(method, params = {}, timeout = 60_000) { + const c = await store.get('nwc'); + if (!c) throw new Error('No wallet is connected. Click the Coinos extension to connect one.'); + const sk = hexToBytes(c.secret); + const content = await nip04.encrypt(sk, c.walletPk, JSON.stringify({ method, params })); + const req = finalizeEvent({ kind: 23194, created_at: Math.floor(Date.now() / 1000), tags: [['p', c.walletPk]], content }, sk); + const release = hold(); + const open = []; + try { + return await new Promise((resolve, reject) => { + let done = false; + let sent = 0; + let failed = 0; + const finish = (fn, v) => { if (!done) { done = true; clearTimeout(timer); fn(v); } }; + const timer = setTimeout(() => finish(reject, new Error(sent ? 'The wallet did not answer in time' : 'Could not reach the wallet\'s relays')), timeout); + const onevent = async (ev) => { + if (done || ev.pubkey !== c.walletPk) return; + try { + const res = JSON.parse(await nip04.decrypt(sk, c.walletPk, ev.content)); + if (res.error) finish(reject, new Error(res.error.message || res.error.code || 'The wallet refused')); + else finish(resolve, res.result || {}); + } catch (_) { /* not ours to read */ } + }; + for (const url of c.relays) { + (async () => { + try { + const relay = await Relay.connect(url); + open.push(relay); + if (done) return; + relay.subscribe([{ kinds: [23195], authors: [c.walletPk], '#e': [req.id] }], { onevent }); + await relay.publish(req); + sent++; + } catch (_) { + if (++failed === c.relays.length) finish(reject, new Error('Could not reach the wallet\'s relays')); + } + })(); + } + }); + } finally { + for (const r of open) { try { r.close(); } catch (_) {} } + release(); + } +} + +// ── what a page may call ─────────────────────────────────────────────────── +const SIGN = new Set(['nostr.getPublicKey', 'nostr.signEvent', 'nostr.getRelays', 'nostr.nip04.encrypt', 'nostr.nip04.decrypt', 'nostr.nip44.encrypt', 'nostr.nip44.decrypt']); +const PAY = new Set(['webln.enable', 'webln.getInfo', 'webln.sendPayment', 'webln.makeInvoice', 'webln.getBalance']); +const hex64 = (s) => typeof s === 'string' && /^[0-9a-f]{64}$/i.test(s); + +async function pageCall(origin, method, p = {}) { + if (SIGN.has(method)) { + const sk = await secretKey(); // "set me up" before "allow this site?" + await allowed(origin, 'sign'); + switch (method) { + case 'nostr.getPublicKey': return getPublicKey(sk); + case 'nostr.getRelays': return {}; + case 'nostr.signEvent': { + const e = p.event || {}; + if (!Number.isInteger(e.kind) || typeof e.content !== 'string') throw new Error('Not a nostr event'); + return finalizeEvent({ + kind: e.kind, + content: e.content, + tags: Array.isArray(e.tags) ? e.tags : [], + created_at: Number.isInteger(e.created_at) ? e.created_at : Math.floor(Date.now() / 1000), + }, sk); + } + } + if (!hex64(p.pubkey)) throw new Error('Not a public key'); + const pk = p.pubkey.toLowerCase(); + switch (method) { + case 'nostr.nip04.encrypt': return nip04.encrypt(sk, pk, String(p.plaintext)); + case 'nostr.nip04.decrypt': return nip04.decrypt(sk, pk, String(p.ciphertext)); + case 'nostr.nip44.encrypt': return nip44.encrypt(String(p.plaintext), nip44.getConversationKey(sk, pk)); + case 'nostr.nip44.decrypt': return nip44.decrypt(String(p.ciphertext), nip44.getConversationKey(sk, pk)); + } + } + if (PAY.has(method)) { + if (!(await store.get('nwc'))) throw new Error('No wallet is connected. Click the Coinos extension to connect one.'); + await allowed(origin, 'pay'); + switch (method) { + case 'webln.enable': return { enabled: true }; + case 'webln.getInfo': return { node: { alias: 'Coinos' }, methods: ['enable', 'getInfo', 'sendPayment', 'makeInvoice', 'getBalance'], supports: ['lightning'] }; + case 'webln.sendPayment': { + const invoice = String(p.paymentRequest || '').trim().replace(/^lightning:/i, ''); + if (!/^ln/i.test(invoice)) throw new Error('Not a Lightning invoice'); + const r = await wallet('pay_invoice', { invoice }, 90_000); + return { preimage: r.preimage || '' }; + } + case 'webln.makeInvoice': { + const a = p.args; + const o = a && typeof a === 'object' ? a : { amount: a }; + const sats = Number(o.amount ?? o.defaultAmount ?? 0); + if (!Number.isFinite(sats) || sats <= 0) throw new Error('An invoice needs an amount'); + const r = await wallet('make_invoice', { amount: Math.round(sats * 1000), description: String(o.defaultMemo || o.memo || '') }); + return { paymentRequest: r.invoice, rHash: r.payment_hash || '' }; + } + case 'webln.getBalance': { + const r = await wallet('get_balance', {}, 20_000); + return { balance: Math.floor((r.balance || 0) / 1000), currency: 'sats' }; + } + } + } + throw new Error(`${method} is not supported by the Coinos extension`); +} + +// ── what the extension's own pages (popup, prompt) may call ──────────────── +async function profileOf(pk) { + // the name and picture for the popup's header, when a relay has them + const cached = await store.get('profile'); + if (cached && cached.pk === pk && Date.now() - cached.at < 6 * 3600_000) return cached; + let relay; + try { + relay = await Relay.connect('wss://relay.coinos.io'); + const ev = await new Promise((resolve) => { + let best = null; + const t = setTimeout(() => resolve(best), 3000); + relay.subscribe([{ kinds: [0], authors: [pk], limit: 1 }], { + onevent: (e) => { if (!best || e.created_at > best.created_at) best = e; }, + oneose: () => { clearTimeout(t); resolve(best); }, + }); + }); + const m = ev ? JSON.parse(ev.content) : {}; + const out = { pk, at: Date.now(), name: String(m.display_name || m.name || '').slice(0, 60), picture: /^https:\/\//.test(m.picture || '') ? m.picture : '', nip05: String(m.nip05 || '').slice(0, 80) }; + await store.set('profile', out); + return out; + } catch (_) { return cached && cached.pk === pk ? cached : null; } + finally { try { relay && relay.close(); } catch (_) {} } +} + +async function ownCall(m) { + switch (m.type) { + case 'state': { + const k = await store.get('key'); + const pk = k ? getPublicKey(hexToBytes(k.sk)) : null; + const c = await store.get('nwc'); + return { pubkey: pk, npub: pk ? nip19.npubEncode(pk) : null, source: k ? k.source : null, wallet: c ? { relays: c.relays } : null, sites: await sitesOf() }; + } + case 'profile': { + const k = await store.get('key'); + return k ? profileOf(getPublicKey(hexToBytes(k.sk))) : null; + } + case 'setKey': await store.set('key', parseKey(m.input)); await store.del('profile'); return true; + case 'removeKey': await store.del('key'); await store.del('profile'); return true; + case 'setWallet': await store.set('nwc', parseNwc(m.uri)); return true; + case 'removeWallet': await store.del('nwc'); return true; + case 'removeSite': { + const sites = await sitesOf(); + delete sites[m.origin]; + await store.set('sites', sites); + return true; + } + case 'balance': { + const r = await wallet('get_balance', {}, 20_000); + return Math.floor((r.balance || 0) / 1000); + } + case 'transactions': { + const r = await wallet('list_transactions', { limit: 12 }, 20_000); + return (r.transactions || []).map((t) => ({ + type: t.type, sats: Math.floor((t.amount || 0) / 1000), at: t.settled_at || t.created_at || 0, memo: String(t.description || '').slice(0, 80), + })); + } + case 'answer': await answerAsk(m); return true; + } + throw new Error('Unknown message'); +} + +chrome.runtime.onMessage.addListener((m, sender, respond) => { + if (!m || typeof m !== 'object') return; + const own = !!sender.url && sender.url.startsWith(chrome.runtime.getURL('')) && sender.id === chrome.runtime.id; + let work; + if (m.type === 'request' && !own) { + let origin = sender.origin; + if (!origin || origin === 'null') { try { origin = new URL(sender.url).origin; } catch (_) { origin = ''; } } + work = /^https?:\/\//.test(origin) ? pageCall(origin, String(m.method), m.params || {}) : Promise.reject(new Error('This page cannot use the Coinos extension')); + } else if (own) { + work = ownCall(m); + } else return; + work.then((result) => respond({ result }), (err) => respond({ error: String((err && err.message) || err) })); + return true; // answered later +}); -- cgit v1.2.3