@dotrino/identity 0.24.0 → 0.25.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotrino/identity",
-  "version": "0.24.0",
+  "version": "0.25.0",
   "description": "Identidad y rating de usuarios compartidos entre apps de Dotrino (vault iframe + postMessage)",
   "type": "module",
   "main": "src/index.js",

package/vault/acta.js

@@ -168,7 +168,9 @@ export async function applyChanges (acta, changes, { by, now = Date.now() } = {}
           label: String(m.label || '').slice(0, 60),
           caps: cleanCaps(m.caps),
           addedAt: now,
-          cert: m.cert || null
+          cert: m.cert || null,
+          // Puente con la identidad que este miembro traía de antes (ver makeContinuity).
+          ...(m.continuity ? { continuity: m.continuity } : {})
         })
         break
       }
@@ -263,6 +265,30 @@ export function memberCan (acta, pub, cap, extraRenounces = []) {
   return effectiveCaps(acta, pub, extraRenounces).includes(cap)
 }
 
+// ----- continuidad: unir una identidad que ya existía -----
+
+/**
+ * CERTIFICADO DE CONTINUIDAD. Cuando una identidad que ya existía entra en otro perfil,
+ * firma —con su propia llave— que a partir de ahora es miembro de él. Sirve de puente:
+ * lo que hizo antes (su reputación, lo que firmó, quien la tenía de contacto) se puede
+ * seguir atribuyendo a la misma persona en vez de quedar huérfano.
+ *
+ * No otorga nada por sí solo: es una declaración del que se une, y solo tiene efecto
+ * dentro del acta donde el master la mete.
+ */
+export async function makeContinuity ({ member, from, privateKey, privateJwk, now = Date.now() }) {
+  const body = { op: 'continuity', member, from: from || member, ts: now }
+  const { signature } = await signWithDevice({ privateKey, privateJwk, publickey: member, data: body })
+  return { ...body, sig: signature }
+}
+
+/** ¿La firmó de verdad la identidad que dice venir? (única comprobación posible). */
+export async function verifyContinuity (record) {
+  if (!record || record.op !== 'continuity' || !isPub(record.member) || typeof record.sig !== 'string') return false
+  const { sig, ...body } = record
+  return verifyDeviceSig({ publickey: record.member, data: body, signature: sig })
+}
+
 // ----- adopción y empates (§2.4.1) -----
 
 /**
@@ -311,5 +337,6 @@ export async function canAdopt ({ candidate, current }) {
 export default {
   ACTA_V, CAPS, CAP_SCOPE, genesisActa, actaBody, actaHash, memberId, checkShape, isHandover,
   sealActa, verifyActa, applyChanges, makeRenounce, verifyRenounce,
+  makeContinuity, verifyContinuity,
   effectiveCaps, memberCan, canAdopt
 }

package/vault/core.js

@@ -1096,7 +1096,13 @@ export async function createIdentityCore ({ kv: rawKv, peers, makeSync = null, k
       // La privada es la CryptoKey del perfil (no extractable): se pasa como `privateKey`
       // y NO se persiste ningún JWK del dispositivo (marcador useIdentityKey).
       const device = { publickey: publickeyJwkStr, privateKey: keypair.privateKey }
-      const res = await remoteEnroll({ qr, device, onChallenge: (c) => emitVault({ phase: 'challenge', deviceId: c.deviceId, code: c.code }) })
+      // Si esta identidad ya existía por su cuenta, se lleva un certificado de continuidad
+      // firmado por ella misma: es el puente para que su reputación previa siga contando.
+      const mio = loadActa()
+      const continuity = (mio && mio.members.length === 1)
+        ? await Acta.makeContinuity({ member: publickeyJwkStr, from: mio.profileId, privateKey: keypair.privateKey })
+        : null
+      const res = await remoteEnroll({ qr, device, continuity, onChallenge: (c) => emitVault({ phase: 'challenge', deviceId: c.deviceId, code: c.code }) })
       kv.setItem(VAULT_DEVICE_STORAGE, JSON.stringify({ useIdentityKey: true, publickey: publickeyJwkStr }))
       kv.setItem(VAULT_CERT_STORAGE, JSON.stringify({ cert: res.cert, master: res.master, proxy: res.proxy, deviceId: res.deviceId, pairedAt: Date.now() }))
       // Conectarse a una bóveda es ENTRAR A SU PERFIL: el acta viene con el cert.

package/vault/remote.js

@@ -56,7 +56,7 @@ async function identifyAsDevice (client, device) {
  * @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 } = {}) {
+export async function enrollDevice ({ qr, device, onChallenge, label = '', continuity = null, 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 })
@@ -75,7 +75,9 @@ export async function enrollDevice ({ qr, device, onChallenge, label = '', appro
     // haber leído el código de ESTA pantalla. Y al ECHARLO de vuelta, el dispositivo confía:
     // una bóveda falsa no conoce el código y no puede enrolarlo.
     const commit = await commitCode({ code, dpub: dev.publickey, sn: qr.sn })
-    const data = { op: 'enroll', dpub: dev.publickey, token: qr.token, sn: qr.sn, commit, label, ts: Date.now() }
+    // `continuity`: si esta identidad ya existía, va firmada por ella misma para que lo
+    // que hizo antes se pueda seguir atribuyendo a la misma persona (ver acta.js).
+    const data = { op: 'enroll', dpub: dev.publickey, token: qr.token, sn: qr.sn, commit, label, ts: Date.now(), ...(continuity ? { continuity } : {}) }
     const { signature } = await signWithDevice({ privateJwk: dev.privateJwk, privateKey: dev.privateKey, publickey: dev.publickey, data })
 
     const enrolled = new Promise((resolve, reject) => {

package/vault/vendor/vault/VERSION.txt

@@ -1,4 +1,4 @@
-Copia vendorizada de @dotrino/vault@0.5.0 (lib/src/{index,enroll}.js, sin dependencias).
+Copia vendorizada de @dotrino/vault@0.6.0 (lib/src/{index,enroll}.js, sin dependencias).
 El iframe de identity se sirve estatico (vanilla, sin build); asi startDeviceVault
 resuelve en el navegador sin bundler. index.js importa ./enroll.js (relativo, se
 vendoriza tambien) y @dotrino/identity/capabilities (=../../capabilities.js) y

package/vault/vendor/vault/enroll.js

@@ -30,6 +30,7 @@
  * `docs/pairing-protocol.md`).
  */
 import { verifyDeviceSig, pubkeyId, commitCode } from '@dotrino/identity/capabilities'
+import { verifyContinuity } from '@dotrino/identity/acta'
 
 /** Un token de emparejamiento vale 5 min. */
 export const PAIRING_TTL_MS = 5 * 60 * 1000
@@ -157,6 +158,12 @@ export function createEnrollDesk ({
     pend.dpub = d.dpub
     pend.deviceId = deviceId
     pend.commit = d.commit
+    // Certificado de continuidad (opcional): lo firma la identidad que se une, con su
+    // propia llave. Se comprueba aquí y se guarda con el miembro al aprobar.
+    if (d.continuity) {
+      const okC = await verifyContinuity(d.continuity)
+      pend.continuity = (okC && d.continuity.member === d.dpub) ? d.continuity : null
+    }
     pend.from = from // la bóveda NO conoce el código: lo aprende cuando lo tipeas
     if (d.label) pend.label = String(d.label).slice(0, 60)
 
@@ -206,7 +213,7 @@ export function createEnrollDesk ({
     try {
       if (typeof identity.admitMember === 'function') {
         const caps = scopeToCaps(pend.scope)
-        if (caps.length) await identity.admitMember({ pub: pend.dpub, label: pend.label || '', caps, cert })
+        if (caps.length) await identity.admitMember({ pub: pend.dpub, label: pend.label || '', caps, cert, continuity: pend.continuity || null })
       }
       acta = (await identity.profileActa?.())?.acta || null
     } catch (e) { log('[vault] no se pudo admitir en el acta:', e.message) }