@dotrino/identity 0.10.0 → 0.12.0

package/README.md

@@ -1,5 +1,7 @@
 # @dotrino/identity
 
+> **Parte del ecosistema [Dotrino](https://dotrino.com).** Misión: aplicaciones que resuelven problemas comunes, respetando tu privacidad — sin anuncios, sin cookies, sin rastreo de datos, sin vender tu identidad a nadie.
+
 Identidad de usuario y rating de peers compartidos entre las apps de Dotrino. Funciona aunque las apps vivan en orígenes distintos: usa un **vault iframe** alojado en un origin estable que guarda la información en su propio `localStorage` y expone una API por `postMessage`.
 
 ## Cómo funciona
@@ -7,8 +9,8 @@ Identidad de usuario y rating de peers compartidos entre las apps de Dotrino. Fu
 ```
 ┌────────────────────┐    postMessage    ┌────────────────────────┐
 │  app (cualquier    │ ◀───────────────▶ │  vault iframe          │
-│  origin: chat,     │                   │  origin: id.closer     │
-│  qrshare, chess…)  │                   │  .click                │
+│  origin: chat,     │                   │  origin: id.dotrino    │
+│  qrshare, chess…)  │                   │  .com                  │
 │                    │                   │  - keypair ECDSA P-256 │
 │  import {Identity} │                   │  - keypair ECDH P-256  │
 └────────────────────┘                   │  - peers + ratings     │

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/identity",
-  "version": "0.10.0",
+  "version": "0.12.0",
   "description": "Identidad y rating de usuarios compartidos entre apps de Dotrino (vault iframe + postMessage)",
   "type": "module",
   "main": "src/index.js",
@@ -41,6 +41,9 @@
     "type": "git",
     "url": "git+https://github.com/imdotrino/dotrino-identity.git"
   },
+  "dependencies": {
+    "@dotrino/proxy-client": "0.6.3"
+  },
   "devDependencies": {
     "fake-indexeddb": "^6.2.5"
   }

package/src/index.js

@@ -197,6 +197,68 @@ export class Identity {
     return this._call('listDelegations')
   }
 
+  // ----- Emparejar ESTE navegador/dispositivo con el vault del usuario (Fase 1) -----
+
+  /**
+   * Empareja este dispositivo con el vault del usuario a partir del QR (v2) que
+   * muestra `dotrino-vault pair`. Genera la sub-clave D DENTRO del iframe (su privada
+   * nunca sale), hace el emparejamiento endurecido por el proxy y guarda el cert.
+   * Emite un evento 'vault' { phase:'challenge', deviceId, sas } para que muestres el
+   * código a comparar; resuelve cuando el dueño aprueba en su PC (espera hasta 3 min).
+   * @returns {Promise<{ ok:boolean, deviceId:string, master:string, exp:number, scope:string[] }>}
+   */
+  async enrollDevice (qr) {
+    return this._call('vaultPair', { qr }, 200000)
+  }
+
+  /** Estado de emparejamiento: { paired, deviceId?, master?, scope?, exp?, pairedAt? }. */
+  async vaultStatus () {
+    return this._call('vaultStatus')
+  }
+
+  /** Desvincula este dispositivo del vault (borra la sub-clave + el cert locales). */
+  async unpairDevice () {
+    return this._call('vaultUnpair')
+  }
+
+  /**
+   * Firma DELEGADA: pide a la maestra del vault (tu PC) que firme `payload`, usando
+   * el cert de este dispositivo. Aditivo y explícito — NO cambia `signData` (local).
+   * Requiere estar emparejado y el vault encendido. Devuelve { signature, publickey }
+   * donde publickey es tu identidad MAESTRA.
+   */
+  async vaultSign (payload) {
+    return this._call('vaultSign', { payload }, 20000)
+  }
+
+  /**
+   * Store DELEGADO: lee/escribe el store de hilos+aperturas (appendMessage,
+   * listThread, recordOpen, getOpens, getStats, …) EN tu vault, usando el cert de
+   * este dispositivo. Reusa el mismo emparejamiento. Requiere el vault encendido.
+   */
+  async vaultStore (method, args) {
+    return this._call('vaultStore', { method, args }, 20000)
+  }
+
+  /** Lista (solo lectura) los dispositivos enrolados en tu vault: { devices, revoked }. */
+  async listVaultDevices () {
+    return this._call('listVaultDevices', {}, 20000)
+  }
+
+  /**
+   * El cert de delegación de este dispositivo (o null si no está emparejado). El
+   * transporte lo presenta al proxy en `identify` → "una identidad": el proxy enruta
+   * los mensajes dirigidos a tu maestra M también a este dispositivo. No tiene secretos.
+   */
+  async getVaultCert () {
+    return this._call('getVaultCert')
+  }
+
+  /** Suscribe a eventos de emparejamiento ('vault'): { phase:'challenge'|'paired'|'unpaired', ... }. */
+  onVault (handler) {
+    return this.on('vault', handler)
+  }
+
   /**
    * Merge endorsements (signed ratings from third parties) about a subject
    * into the local peer book. Returns { merged, total }.
@@ -334,7 +396,7 @@ export class Identity {
     }
   }
 
-  _call (method, params = {}) {
+  _call (method, params = {}, timeoutMs = this.timeoutMs) {
     return new Promise((resolve, reject) => {
       if (!this._iframe?.contentWindow) {
         return reject(new Error('Vault not ready'))
@@ -343,7 +405,7 @@ export class Identity {
       const timer = setTimeout(() => {
         this._pending.delete(id)
         reject(new Error(`Vault timeout for ${method}`))
-      }, this.timeoutMs)
+      }, timeoutMs)
       this._pending.set(id, { resolve, reject, timer })
 
       // Usamos targetOrigin='*' por compatibilidad: en algunos navegadores el
@@ -364,4 +426,4 @@ export class Identity {
 
 // Helpers de capacidad SIN clave maestra (lado dispositivo + verificación), reutilizables
 // por apps/bridges sin cargar el iframe del vault.
-export { makeDeviceKey, signWithDevice, verifyDelegation, verifyChain, pubkeyId, MAX_DELEGATION_MS, DEFAULT_DELEGATION_MS } from '../vault/capabilities.js'
+export { makeDeviceKey, signWithDevice, verifyDelegation, verifyChain, pubkeyId, deriveSAS, verifyDeviceSig, MAX_DELEGATION_MS, DEFAULT_DELEGATION_MS } from '../vault/capabilities.js'

package/src/node.js

@@ -99,6 +99,7 @@ export class Identity {
       makeSync: null
     })
     this._core.onSyncStatus((payload) => this._emit('sync', payload))
+    this._core.onVaultEvent((payload) => this._emit('vault', payload))
     return this
   }
 
@@ -134,6 +135,15 @@ export class Identity {
   signDelegation (sub, scope, opts = {}) { return this._h('signDelegation', { sub, scope, ...opts }) }
   revokeDelegation (nonce) { return this._h('revokeDelegation', { nonce }) }
   listDelegations () { return this._h('listDelegations') }
+  // Emparejar ESTE dispositivo con el vault del usuario (Fase 1)
+  enrollDevice (qr) { return this._h('vaultPair', { qr }) }
+  vaultStatus () { return this._h('vaultStatus') }
+  unpairDevice () { return this._h('vaultUnpair') }
+  vaultSign (payload) { return this._h('vaultSign', { payload }) }
+  vaultStore (method, args) { return this._h('vaultStore', { method, args }) }
+  listVaultDevices () { return this._h('listVaultDevices') }
+  getVaultCert () { return this._h('getVaultCert') }
+  onVault (handler) { return this.on('vault', handler) }
   mergeEndorsements (subject, endorsements, askerPubkey) {
     return this._h('mergeEndorsements', { subject, endorsements, askerPubkey })
   }
@@ -176,4 +186,4 @@ export default Identity
 
 // Helpers de capacidad SIN clave maestra (lado dispositivo + verificación), para que
 // un bridge/bot Node pueda crear su clave, firmar acciones y verificar cadenas D←P.
-export { makeDeviceKey, signWithDevice, verifyDelegation, verifyChain, pubkeyId, MAX_DELEGATION_MS, DEFAULT_DELEGATION_MS } from '../vault/capabilities.js'
+export { makeDeviceKey, signWithDevice, verifyDelegation, verifyChain, pubkeyId, deriveSAS, verifyDeviceSig, MAX_DELEGATION_MS, DEFAULT_DELEGATION_MS } from '../vault/capabilities.js'

package/vault/capabilities.js

@@ -53,6 +53,30 @@ export async function pubkeyId (publicJwkStr) {
   return [...new Uint8Array(h)].map(b => b.toString(16).padStart(2, '0')).join('')
 }
 
+/**
+ * Verifica que `signature` (base64) sobre `data` fue hecha por la privada de
+ * `publickey` (JWK string). Prueba de POSESION de una sub-clave de dispositivo (no
+ * es cadena de delegacion): la usa el vault para confirmar que quien pide enrolar
+ * `dpub` realmente tiene su privada (un token robado ya no alcanza para enrolar).
+ */
+export async function verifyDeviceSig ({ publickey, data, signature }) {
+  if (typeof publickey !== 'string' || typeof signature !== 'string') return false
+  return rawVerify(publickey, enc(canonicalStringify(data)), signature)
+}
+
+/**
+ * Short Authentication String: 6 digitos deterministas derivados de (maestra,
+ * dispositivo, nonce de sesion). NO es un secreto: su valor esta en COMPARARLO
+ * visualmente entre las dos pantallas (PC del vault y dispositivo) al emparejar —
+ * eso mata el relay/phishing (un atacante remoto no puede mostrar el SAS correcto
+ * en el dispositivo fisico de la victima).
+ */
+export async function deriveSAS (master, dpub, sn) {
+  const h = new Uint8Array(await crypto.subtle.digest('SHA-256', enc(canonicalStringify({ iss: master, sub: dpub, sn }))))
+  const n = ((h[0] << 24) | (h[1] << 16) | (h[2] << 8) | h[3]) >>> 0
+  return String(n % 1000000).padStart(6, '0')
+}
+
 /** Cuerpo canónico del certificado (lo que se firma): el cert SIN la firma. */
 export function delegationBody (cert) {
   return { v: cert.v, iss: cert.iss, sub: cert.sub, scope: cert.scope, iat: cert.iat, exp: cert.exp, nonce: cert.nonce }

package/vault/core.js

@@ -19,6 +19,7 @@
  */
 
 import { signDelegationWith, MAX_DELEGATION_MS, DEFAULT_DELEGATION_MS } from './capabilities.js'
+import { enrollDevice as remoteEnroll, requestSign as remoteSign, requestStore as remoteStore, requestDevices as remoteDevices } from './remote.js'
 
 export const KEY_STORAGE = 'dotrino.identity.keypair'
 export const ENC_KEY_STORAGE = 'dotrino.identity.enc-keypair'
@@ -26,6 +27,8 @@ export const ME_STORAGE = 'dotrino.identity.me'
 export const NONCE_STORAGE = 'dotrino.identity.nonces' // replay window
 export const DELEGATIONS_STORAGE = 'dotrino.identity.delegations'   // caps emitidas
 export const REVOCATIONS_STORAGE = 'dotrino.identity.revocations'   // nonces revocados
+export const VAULT_DEVICE_STORAGE = 'dotrino.identity.vault.device' // sub-clave D de ESTE dispositivo (custodia en el iframe)
+export const VAULT_CERT_STORAGE = 'dotrino.identity.vault.cert'     // { cert, master, proxy, deviceId, pairedAt }
 
 const NONCE_TTL_MS = 5 * 60 * 1000
 
@@ -168,6 +171,13 @@ export async function createIdentityCore ({ kv, peers, makeSync = null }) {
   const loadRevocations = () => loadJson(REVOCATIONS_STORAGE)
   const saveRevocations = (o) => kv.setItem(REVOCATIONS_STORAGE, JSON.stringify(o))
 
+  // ----- emparejamiento con el vault del usuario (este dispositivo enrolado) -----
+  // Canal de eventos 'vault' (p.ej. el SAS a comparar durante el emparejamiento).
+  const vaultListeners = new Set()
+  const emitVault = (p) => { for (const fn of vaultListeners) { try { fn(p) } catch (_) {} } }
+  const loadVaultCert = () => { try { return JSON.parse(kv.getItem(VAULT_CERT_STORAGE) || 'null') } catch (_) { return null } }
+  const loadVaultDevice = () => { try { return JSON.parse(kv.getItem(VAULT_DEVICE_STORAGE) || 'null') } catch (_) { return null } }
+
   // ----- me (kv-backed) -----
 
   function loadMe () {
@@ -501,6 +511,65 @@ export async function createIdentityCore ({ kv, peers, makeSync = null }) {
       }
     },
 
+    // ----- emparejar ESTE dispositivo con el vault del usuario (Fase 1) -----
+    // Genera D aquí dentro (su privada NUNCA sale de la identidad), hace el enroll
+    // endurecido por el proxy y guarda el cert. NO cambia signData todavía (Fase 2).
+    async vaultPair ({ qr }) {
+      // Usa la PROPIA llave de identidad de este navegador como dispositivo: el cert delega
+      // TU identidad (P) desde la maestra M → una sola identidad (signData/identify/cert = P).
+      let device
+      try { const k = JSON.parse(kv.getItem(KEY_STORAGE)); device = { publickey: JSON.stringify(k.publicJwk), privateJwk: k.privateJwk } } catch (_) { device = undefined }
+      const res = await remoteEnroll({ qr, device, onChallenge: (c) => emitVault({ phase: 'challenge', deviceId: c.deviceId, sas: c.sas }) })
+      kv.setItem(VAULT_DEVICE_STORAGE, JSON.stringify(res.device))
+      kv.setItem(VAULT_CERT_STORAGE, JSON.stringify({ cert: res.cert, master: res.master, proxy: res.proxy, deviceId: res.deviceId, pairedAt: Date.now() }))
+      emitVault({ phase: 'paired', deviceId: res.deviceId, master: res.master })
+      return { ok: true, deviceId: res.deviceId, master: res.master, exp: res.cert.exp, scope: res.cert.scope }
+    },
+
+    async vaultStatus () {
+      const v = loadVaultCert()
+      if (!v?.cert) return { paired: false }
+      return { paired: true, deviceId: v.deviceId, master: v.master, proxy: v.proxy, scope: v.cert.scope, exp: v.cert.exp, pairedAt: v.pairedAt }
+    },
+
+    async vaultUnpair () {
+      kv.removeItem(VAULT_DEVICE_STORAGE)
+      kv.removeItem(VAULT_CERT_STORAGE)
+      emitVault({ phase: 'unpaired' })
+      return { ok: true }
+    },
+
+    // Firma DELEGADA: pide a la maestra del vault que firme `payload` (con el cert de
+    // este dispositivo). Aditivo y explícito — NO cambia `signData` (que sigue local),
+    // así nada se rompe si no estás emparejado o si el vault está apagado.
+    async vaultSign ({ payload }) {
+      const v = loadVaultCert(); const device = loadVaultDevice()
+      if (!v?.cert || !device) throw new Error('este dispositivo no está emparejado con un vault')
+      return remoteSign({ master: v.master, proxy: v.proxy, device, cert: v.cert, payload })
+    },
+
+    // Store DELEGADO: lee/escribe el store de hilos+aperturas EN tu vault (con el cert).
+    // Reusa el MISMO emparejamiento (no hay un pairing aparte para el store).
+    async vaultStore ({ method, args }) {
+      const v = loadVaultCert(); const device = loadVaultDevice()
+      if (!v?.cert || !device) throw new Error('este dispositivo no está emparejado con un vault')
+      return remoteStore({ master: v.master, proxy: v.proxy, device, cert: v.cert, method, args })
+    },
+
+    // Lista (solo lectura) de dispositivos enrolados en tu vault.
+    async listVaultDevices () {
+      const v = loadVaultCert(); const device = loadVaultDevice()
+      if (!v?.cert || !device) throw new Error('este dispositivo no está emparejado con un vault')
+      return remoteDevices({ master: v.master, proxy: v.proxy, device, cert: v.cert })
+    },
+
+    // El cert de delegación de este dispositivo (para presentarlo al proxy en `identify`
+    // → "una identidad": el proxy bindea tu pubkey también bajo tu maestra M). Sin secretos.
+    async getVaultCert () {
+      const v = loadVaultCert()
+      return v?.cert ? { cert: v.cert, master: v.master } : null
+    },
+
     async listContacts () {
       return Object.values(loadPeers()).filter(p => p && p.isContact).sort((a, b) => (b.lastSeen || 0) - (a.lastSeen || 0))
     },
@@ -636,6 +705,7 @@ export async function createIdentityCore ({ kv, peers, makeSync = null }) {
     handlers,
     get me () { return me },
     sync,
-    onSyncStatus (fn) { if (sync) sync.onStatus(fn) }
+    onSyncStatus (fn) { if (sync) sync.onStatus(fn) },
+    onVaultEvent (fn) { vaultListeners.add(fn); return () => vaultListeners.delete(fn) }
   }
 }

package/vault/index.html

@@ -19,6 +19,11 @@
     <li>Nicknames and ratings of peers you've met.</li>
   </ul>
   <p>Source: <a href="https://github.com/imdotrino/dotrino-identity" target="_blank" rel="noopener">github.com/imdotrino/dotrino-identity</a></p>
+  <!-- Transporte self-hosted (vendorizado): el emparejamiento de dispositivos importa
+       @dotrino/proxy-client de forma perezosa; este import map lo resuelve sin CDN. -->
+  <script type="importmap">
+  { "imports": { "@dotrino/proxy-client": "./vendor/proxy-client/index.js" } }
+  </script>
   <script type="module" src="./vault.js"></script>
 </body>
 </html>

package/vault/remote.js

@@ -0,0 +1,131 @@
+/**
+ * Enrolamiento de ESTE dispositivo contra el vault del usuario (lado dispositivo).
+ *
+ * Corre dentro del iframe de identidad (o headless en Node): genera la sub-clave `D`
+ * —cuya privada NUNCA sale de la identidad—, hace el emparejamiento ENDURECIDO por el
+ * proxy (ver dotrino-vault/docs/pairing-protocol.md) y devuelve el cert ya validado.
+ *
+ * Flujo: firma el ENROLL con D (prueba de posesión) → recibe el reto y computa SU
+ * propio SAS (que el usuario compara con el del PC) → al ser aprobado en el PC, recibe
+ * el cert y lo valida (firmado por la maestra que vio en el QR, y para SU clave).
+ *
+ * No reimplementa cripto: usa `@dotrino/identity/capabilities`. Transporte:
+ * `@dotrino/proxy-client` (importado perezosamente; solo se carga al emparejar).
+ */
+import { makeDeviceKey, signWithDevice, verifyDelegation, deriveSAS, pubkeyId } from './capabilities.js'
+
+const MSG = {
+  ENROLL: 'vault.enroll',
+  ENROLL_CHALLENGE: 'vault.enroll.challenge',
+  ENROLLED: 'vault.enrolled',
+  ERROR: 'vault.error'
+}
+
+/**
+ * @param {Object} opts
+ * @param {{v:number, iss:string, proxy:string, token:string, sn:string}} opts.qr  QR v2 del vault.
+ * @param {(c:{deviceId:string, sas:string})=>void} [opts.onChallenge]  Para mostrar el SAS a comparar.
+ * @param {string} [opts.label]
+ * @param {number} [opts.approveTimeoutMs]  Espera de la aprobación humana (def 3 min).
+ * @returns {Promise<{device, cert, master:string, proxy:string, deviceId:string}>}
+ */
+export async function enrollDevice ({ qr, device, onChallenge, label = '', approveTimeoutMs = 180000 } = {}) {
+  if (!qr?.iss || !qr?.proxy || !qr?.token || !qr?.sn) throw new Error('qr inválido (v2): faltan iss/proxy/token/sn')
+  const { WebSocketProxyClient } = await import('@dotrino/proxy-client')
+  const client = new WebSocketProxyClient({ url: qr.proxy, enableWebRTC: false, autoReconnect: false })
+  await client.connect()
+  try {
+    // Por defecto genera una sub-clave nueva; pero el iframe pasa SU PROPIA llave de
+    // identidad (P) como `device` → el cert delega tu identidad y hay UNA sola (signData/
+    // identify/cert son la misma P).
+    const dev = device || await makeDeviceKey({ label })
+    const deviceId = (await pubkeyId(dev.publickey)).slice(0, 8).toUpperCase().replace(/(.{4})(.{4})/, '$1-$2')
+    const sas = await deriveSAS(qr.iss, dev.publickey, qr.sn)
+    const data = { op: 'enroll', dpub: dev.publickey, token: qr.token, sn: qr.sn, label, ts: Date.now() }
+    const { signature } = await signWithDevice({ privateJwk: dev.privateJwk, data })
+
+    const enrolled = new Promise((resolve, reject) => {
+      const off = client.on('message', (_from, p) => {
+        if (!p || typeof p !== 'object') return
+        if (p.type === MSG.ENROLL_CHALLENGE) { try { onChallenge?.({ deviceId, sas }) } catch (_) {} }
+        else if (p.type === MSG.ENROLLED) { cleanup(); resolve(p) }
+        else if (p.type === MSG.ERROR) { cleanup(); reject(new Error(p.error)) }
+      })
+      const t = setTimeout(() => { cleanup(); reject(new Error('timeout esperando la aprobación en el vault')) }, approveTimeoutMs)
+      const cleanup = () => { off(); clearTimeout(t) }
+    })
+    client.sendByPubkey(qr.iss, { type: MSG.ENROLL, data, signature })
+    const res = await enrolled
+
+    // Validación estricta antes de guardar (cierra inyección de cert / sustitución de maestra).
+    const v = await verifyDelegation({ cert: res.cert, expectedSub: dev.publickey })
+    if (!v.ok) throw new Error('cert inválido: ' + v.reason)
+    if (res.cert.iss !== qr.iss) throw new Error('cert firmado por una maestra distinta a la que viste')
+    if (res.cert.sub !== dev.publickey) throw new Error('cert emitido para otro dispositivo')
+    return { device: dev, cert: res.cert, master: qr.iss, proxy: qr.proxy, deviceId }
+  } finally { try { client.close() } catch (_) {} }
+}
+
+/**
+ * Pide a la MAESTRA (en el vault del PC) que firme `payload`, adjuntando el cert de
+ * delegación de este dispositivo. La maestra nunca sale del vault: vuelve solo la
+ * firma. Requiere que el vault esté online.
+ * @returns {Promise<{ signature:string, publickey:string }>}  publickey = la maestra.
+ */
+export async function requestSign ({ master, proxy, device, cert, payload, timeoutMs = 15000 } = {}) {
+  if (!master || !proxy || !device?.privateJwk || !cert) throw new Error('faltan datos de emparejamiento')
+  const { WebSocketProxyClient } = await import('@dotrino/proxy-client')
+  const client = new WebSocketProxyClient({ url: proxy, enableWebRTC: false, autoReconnect: false })
+  await client.connect()
+  try {
+    const data = { op: 'sign', payload, publickey: device.publickey, ts: Date.now() }
+    const { signature } = await signWithDevice({ privateJwk: device.privateJwk, data })
+    const pending = new Promise((resolve, reject) => {
+      const off = client.on('message', (_f, p) => {
+        if (!p || typeof p !== 'object') return
+        if (p.type === 'vault.signed') { cleanup(); resolve(p) }
+        else if (p.type === 'vault.error') { cleanup(); reject(new Error(p.error)) }
+      })
+      const t = setTimeout(() => { cleanup(); reject(new Error('el vault no respondió (¿está encendido?)')) }, timeoutMs)
+      const cleanup = () => { off(); clearTimeout(t) }
+    })
+    client.sendByPubkey(master, { type: 'vault.sign', data, signature, cert })
+    const res = await pending
+    return { signature: res.signature, publickey: res.publickey }
+  } finally { try { client.close() } catch (_) {} }
+}
+
+/** Helper genérico: una RPC al vault firmada por D + cert, esperando `okType`. */
+async function vaultRpc ({ master, proxy, device, cert, sendType, okType, data, timeoutMs = 15000 }) {
+  if (!master || !proxy || !device?.privateJwk || !cert) throw new Error('faltan datos de emparejamiento')
+  const { WebSocketProxyClient } = await import('@dotrino/proxy-client')
+  const client = new WebSocketProxyClient({ url: proxy, enableWebRTC: false, autoReconnect: false })
+  await client.connect()
+  try {
+    const signed = { ...data, publickey: device.publickey, ts: Date.now() }
+    const { signature } = await signWithDevice({ privateJwk: device.privateJwk, data: signed })
+    const pending = new Promise((resolve, reject) => {
+      const off = client.on('message', (_f, p) => {
+        if (!p || typeof p !== 'object') return
+        if (p.type === okType) { cleanup(); resolve(p) }
+        else if (p.type === 'vault.error') { cleanup(); reject(new Error(p.error)) }
+      })
+      const t = setTimeout(() => { cleanup(); reject(new Error('el vault no respondió (¿está encendido?)')) }, timeoutMs)
+      const cleanup = () => { off(); clearTimeout(t) }
+    })
+    client.sendByPubkey(master, { type: sendType, data: signed, signature, cert })
+    return await pending
+  } finally { try { client.close() } catch (_) {} }
+}
+
+/** Lee/escribe el store de hilos+aperturas EN el vault (con el cert del dispositivo). */
+export async function requestStore ({ master, proxy, device, cert, method, args } = {}) {
+  const res = await vaultRpc({ master, proxy, device, cert, sendType: 'vault.store', okType: 'vault.store.result', data: { op: 'store', method, args: args || {} } })
+  return res.result
+}
+
+/** Lista (solo lectura) los dispositivos enrolados en tu vault. */
+export async function requestDevices ({ master, proxy, device, cert } = {}) {
+  const res = await vaultRpc({ master, proxy, device, cert, sendType: 'vault.devices', okType: 'vault.devices.result', data: { op: 'devices' } })
+  return { devices: res.devices || [], revoked: res.revoked || [] }
+}

package/vault/vault.js

@@ -30,17 +30,15 @@ import { createIdentityCore } from './core.js'
 
   const { handlers } = core
 
-  // Broadcast de estado del sync a todos los embebedores.
-  const broadcastStatus = (payload) => {
+  // Broadcast de eventos del vault (sync + emparejamiento) a todos los embebedores.
+  const broadcast = (eventName, payload) => {
     for (const w of [window.parent, ...Array.from(document.querySelectorAll('iframe')).map(f => f.contentWindow)]) {
       if (!w || w === window) continue
-      try { w.postMessage({ _cci: true, type: 'event', event: 'sync', payload }, '*') } catch {}
-    }
-    if (window.parent && window.parent !== window) {
-      try { window.parent.postMessage({ _cci: true, type: 'event', event: 'sync', payload }, '*') } catch {}
+      try { w.postMessage({ _cci: true, type: 'event', event: eventName, payload }, '*') } catch {}
     }
   }
-  core.onSyncStatus(broadcastStatus)
+  core.onSyncStatus((p) => broadcast('sync', p))
+  core.onVaultEvent((p) => broadcast('vault', p))
 
   window.addEventListener('message', async (event) => {
     const msg = event.data

package/vault/vendor/proxy-client/VERSION.txt

@@ -0,0 +1,2 @@
+Copia vendorizada de @dotrino/proxy-client@0.6.4 (src/, sin dependencias).
+Ver dotrino-identity: el iframe se sirve estatico, transporte self-hosted (no CDN).

package/vault/vendor/proxy-client/canonical.js

@@ -0,0 +1,15 @@
+/**
+ * Canonical JSON serialization (sorted keys recursively).
+ * Necessary so that signatures match across implementations.
+ */
+export function canonicalStringify (value) {
+  if (value === null || typeof value !== 'object') {
+    return JSON.stringify(value)
+  }
+  if (Array.isArray(value)) {
+    return '[' + value.map(canonicalStringify).join(',') + ']'
+  }
+  const keys = Object.keys(value).sort()
+  const parts = keys.map(k => JSON.stringify(k) + ':' + canonicalStringify(value[k]))
+  return '{' + parts.join(',') + '}'
+}