@dotrino/identity 0.115.0 → 0.116.0

package/vault/vendor/passmanager/vault/interface.js

@@ -0,0 +1,34 @@
+/**
+ * El contrato que consumen la extensión, la consola web y la app nativa. Quién esté
+ * detrás (el vault del PC, el teléfono, o la caché local) es intercambiable — esa es
+ * la razón de que exista esta interfaz y no se lea el almacén directamente
+ * (DISENO §6.1).
+ *
+ *   find(url)  → [publicView]   qué hay para este sitio. SIN secretos: sirve para
+ *                               elegir entre varias cuentas, no para usarlas.
+ *   get(id, {keys}) → entrada abierta   UNA credencial, y solo los campos pedidos.
+ *                               Pedir algo PRIVADO exige aprobación; lo público, no.
+ *   put(entry) → publicView     crear o actualizar. Exige una bóveda de verdad.
+ *   patch(id, changes) → publicView   cambiar unos campos SIN leer la entrada antes: la
+ *                               fusión la hace quien tiene el dato. No exige aprobación
+ *                               —no sale nada— y no puede perder lo que no se tocó.
+ *   search(q)  → [publicView]   buscar por texto en TODA la bóveda, con tope. Exige un
+ *                               término que escribe una persona; no es `list`.
+ *   remove(id) → void           quitarla. La borra quien la tiene, no quien la pide.
+ *   list()     → [publicView]   la bóveda entera. Exige la CEK.
+ *
+ * `list` no está para la extensión: si pudiera listarlo todo, el "pide de a una"
+ * (DISENO §2) sería decorativo.
+ *
+ * Toda implementación expone además:
+ *   capabilities → { canWrite, canList, needsApproval }
+ */
+export const VaultSource = {
+  async find (_url) { throw new Error('not implemented') },
+  async get (_id, _opts) { throw new Error('not implemented') },
+  async put (_entry) { throw new Error('not implemented') },
+  async patch (_id, _changes) { throw new Error('not implemented') },
+  async search (_q, _opts) { throw new Error('not implemented') },
+  async remove (_id) { throw new Error('not implemented') },
+  async list () { throw new Error('not implemented') },
+}

package/vault/vendor/passmanager/vault/local.js

@@ -0,0 +1,213 @@
+// Bóveda local: la que corre donde SÍ está la CEK — el vault del PC, la app nativa,
+// y la caché opt-in de solo lectura de la extensión (DISENO §3).
+//
+// El almacén se inyecta para no atar la librería a nada: en la app es
+// `@dotrino/store`, en la extensión `chrome.storage.local`, en las pruebas un Map.
+// Solo tiene que cumplir `{ get(k), set(k, v) }`.
+
+import { openEntry, sealEntry, mergePatch, publicView, entryWho, normalizeSites } from '../model.js'
+import { entryDigestValues, fieldKey, normalizeFields, KINDS } from '../fields.js'
+import { makeNonce, fieldHasher } from '../crypto.js'
+import { findForUrl } from '../match.js'
+import { VaultError, CODES } from './errors.js'
+
+const KEY = 'passmanager/entries/v1'
+
+export class LocalVault {
+  /**
+   * @param {object} store almacén `{ get(k), set(k, v) }`
+   * @param {object} opts  `{ readOnly }` — la caché de la extensión va en `true`
+   */
+  constructor (store, opts = {}) {
+    this.store = store
+    this.readOnly = !!opts.readOnly
+    this.key = null
+  }
+
+  get capabilities () {
+    return { canWrite: !this.readOnly, canList: true, needsApproval: false }
+  }
+
+  /** Entrega la CEK. Sin esto, todo lo demás falla con `locked`. */
+  unlock (cek) {
+    this.key = cek
+  }
+
+  lock () {
+    this.key = null
+  }
+
+  #requireKey () {
+    if (!this.key) throw new VaultError(CODES.LOCKED, 'la bóveda está cerrada')
+  }
+
+  async #all () {
+    return (await this.store.get(KEY)) || []
+  }
+
+  /**
+   * Los RESÚMENES de los campos de una entrada, para que quien pregunta pueda comparar
+   * sin abrir nada (§4.0.2). Un nonce por respuesta, no por entrada: así dos entradas de
+   * la misma respuesta se pueden comparar contra lo mismo, y entre dos respuestas no hay
+   * nada que correlacionar.
+   */
+  async #digest (nonce, hash, open) {
+    const fields = {}
+    for (const f of entryDigestValues(open)) fields[f.key] = await hash(f.key, f.value)
+    return { nonce, fields }
+  }
+
+  async find (url) {
+    this.#requireKey()
+    const hits = findForUrl(await this.#all(), url)
+    const nonce = makeNonce()
+    const hash = await fieldHasher(nonce)
+    // El nombre visible obliga a abrir la entrada: por eso lo calcula quien tiene la CEK,
+    // y no quien pregunta. Lo mismo los resúmenes.
+    return Promise.all(hits.map(async ({ entry }) => {
+      const open = await openEntry(this.key, entry)
+      return publicView(entry, entryWho(open), open, await this.#digest(nonce, hash, open))
+    }))
+  }
+
+  async get (id) {
+    this.#requireKey()
+    const entry = (await this.#all()).find(e => e.id === id)
+    if (!entry) throw new VaultError(CODES.NOT_FOUND, 'no hay ninguna entrada con ese id')
+    return openEntry(this.key, entry)
+  }
+
+  async put (plain) {
+    this.#requireKey()
+    if (this.readOnly) throw new VaultError(CODES.READ_ONLY, 'esta copia solo puede leer')
+    const sealed = await sealEntry(this.key, plain)
+    const all = await this.#all()
+    const i = all.findIndex(e => e.id === sealed.id)
+    if (i >= 0) {
+      sealed.createdAt = all[i].createdAt
+      all[i] = sealed
+    } else {
+      all.push(sealed)
+    }
+    await this.store.set(KEY, all)
+    return publicView(sealed)
+  }
+
+  /**
+   * CAMBIAR unos campos de una entrada, dejando el resto como estaba.
+   *
+   * Existe para que quien guarda **no tenga que leerla antes**. Antes el aparato hacía
+   * `get` + fusionar + `put`, y eso tenía dos costes que no se veían: sacaba de la bóveda
+   * la entrada entera —contraseña incluida— para escribir un teléfono, y si esa lectura
+   * fallaba, el `put` que venía detrás escribía la entrada **sin lo que no pudo leer**.
+   * Eso no es un fallo raro: es perder datos por una autorización denegada.
+   *
+   * Aquí la fusión ocurre donde vive el dato. Lo que no venga en `changes` no se toca, y
+   * si la entrada no existe no se crea nada — para crear está `put`.
+   *
+   * `changes`:
+   *   `name`, `title`, `username`, `secret`, `totp`, `notes`  cada uno, si viene, reemplaza
+   *   `fields`  lista `{ label, value, kind, private }`; se casan por su clave (§4.2),
+   *             los que no aparecen se quedan. **`value` sin poner no toca el valor**:
+   *             sirve para cambiar solo la marca de privado, que es lo único que se puede
+   *             hacer desde el gestor con un campo cuyo valor no se tiene delante
+   *   `removeFields`  claves que se van. Un campo libre desaparece; uno de los de siempre
+   *             (`username`, `secret`, `totp`, `notes`) se queda vacío, que es lo mismo
+   *   `sites`   la lista ENTERA, tal cual queda. Es lo que manda el gestor, que la edita
+   *             a mano; vacía significa «sirve en cualquier sitio», que es lo que la
+   *             ausencia de sitios ha significado siempre. Si viene, `addSite` se ignora
+   *   `addSite` suma este sitio **solo si la entrada ya tenía alguno**: una entrada sin
+   *             sitios sirve en cualquier parte, y atarla al primer formulario donde se
+   *             usó sería quitarle eso sin que nadie lo pidiera
+   */
+  async patch (id, changes = {}) {
+    this.#requireKey()
+    if (this.readOnly) throw new VaultError(CODES.READ_ONLY, 'esta copia solo puede leer')
+    const all = await this.#all()
+    const i = all.findIndex(e => e.id === id)
+    if (i < 0) throw new VaultError(CODES.NOT_FOUND, 'no hay ninguna entrada con ese id')
+
+    const base = await openEntry(this.key, all[i])
+    // La fusión vive en `model.js` y la comparten esta bóveda y la sellada: no es un
+    // `{...a, ...b}` —un campo sin `value` dice «déjale el que tenga»— y dos copias de esa
+    // sutileza son una que se queda atrás.
+    const sealed = await sealEntry(this.key, mergePatch(base, changes))
+    all[i] = sealed
+    await this.store.set(KEY, all)
+    return publicView(sealed)
+  }
+
+  /**
+   * EN QUÉ SITIOS HAY ALGO GUARDADO, y cuánto en cada uno.
+   *
+   * Es lo que le permite al gestor abrir con la lista de dominios en vez de con un
+   * buscador en blanco (dueño, 2026-08-29). **No es `list`**, y la diferencia no es de
+   * grado: de aquí no sale ni un id, ni un nombre, ni qué campos lleva nadie, ni un
+   * resumen con el que comparar. Sale el dominio, que **ya viaja en claro** —`sites` no
+   * se cifra, porque hace falta para emparejar con la página sin tener la CEK (§5)— y
+   * cuántas entradas hay en él.
+   *
+   * Lo que sí concede, y conviene decirlo: hoy hay que preguntar sitio por sitio para
+   * saber dónde tienes cuenta, y esto lo contesta de una vez. Es la razón de que el
+   * dueño lo decidiera a propósito y no se colara como un detalle.
+   *
+   * `site: ''` son las entradas SIN sitio, que sirven en cualquier parte.
+   */
+  async sites () {
+    this.#requireKey()
+    const cuenta = new Map()
+    for (const e of await this.#all()) {
+      const suyos = e.sites?.length ? e.sites : ['']
+      for (const s of suyos) cuenta.set(s, (cuenta.get(s) || 0) + 1)
+    }
+    return [...cuenta.entries()]
+      .map(([site, count]) => ({ site, count }))
+      .sort((a, b) => (a.site === '' ? 1 : b.site === '' ? -1 : a.site.localeCompare(b.site)))
+  }
+
+  /**
+   * BUSCAR por texto en toda la bóveda. Devuelve lo público, y como mucho `limit`.
+   *
+   * No es `list` con otro nombre, y la diferencia importa (DISENO §2): `list` lo puede
+   * pedir el código en cualquier momento y devuelve todo; esto exige un término que
+   * **escribe una persona** y devuelve un puñado. Existe porque a veces la cuenta que
+   * sirve está guardada en otro dominio —el subdominio cambió y la clave es la misma— y
+   * sin buscarla no hay forma de llegar a ella.
+   *
+   * Se busca en lo que identifica a la entrada: su título, sus sitios y su nombre
+   * visible. **Nunca en los valores de los campos**: buscar «1700» y que aparezca tu
+   * documento es exactamente lo que no puede pasar.
+   */
+  async search (q, { limit = 20 } = {}) {
+    this.#requireKey()
+    const texto = String(q || '').trim().toLowerCase()
+    if (texto.length < 2) return []
+    const nonce = makeNonce()
+    const hash = await fieldHasher(nonce)
+    const out = []
+    for (const entry of await this.#all()) {
+      if (out.length >= limit) break
+      const open = await openEntry(this.key, entry)
+      const quien = entryWho(open)
+      const heno = [entry.title, quien, ...(entry.sites || [])].filter(Boolean).join(' ').toLowerCase()
+      if (heno.includes(texto)) {
+        out.push(publicView(entry, quien, open, await this.#digest(nonce, hash, open)))
+      }
+    }
+    return out
+  }
+
+  async remove (id) {
+    this.#requireKey()
+    if (this.readOnly) throw new VaultError(CODES.READ_ONLY, 'esta copia solo puede leer')
+    const all = await this.#all()
+    const rest = all.filter(e => e.id !== id)
+    if (rest.length === all.length) throw new VaultError(CODES.NOT_FOUND, 'no hay ninguna entrada con ese id')
+    await this.store.set(KEY, rest)
+  }
+
+  async list () {
+    this.#requireKey()
+    return (await this.#all()).map(e => publicView(e))
+  }
+}

package/vault/vendor/passmanager/vault/remote.js

@@ -0,0 +1,85 @@
+// Bóveda remota: la que usa la extensión de Chrome por defecto (DISENO §2).
+//
+// No tiene la CEK y no guarda nada. Pregunta por un dominio, recibe metadatos, y
+// pide UNA credencial cuando el usuario elige. Quién responde al otro lado del
+// transporte —el vault del PC o el teléfono— le da igual.
+
+import { VaultError, CODES } from './errors.js'
+
+export class RemoteVault {
+  /**
+   * @param {object} transport `{ request(op, payload) }` — proxy, WebSocket o
+   *   `chrome.runtime` según dónde corra. Devuelve la respuesta ya deserializada.
+   */
+  constructor (transport, opts = {}) {
+    this.transport = transport
+    this.needsApproval = opts.needsApproval !== false
+  }
+
+  get capabilities () {
+    return { canWrite: true, canList: false, needsApproval: this.needsApproval }
+  }
+
+  async find (url) {
+    return this.#request('find', { url })
+  }
+
+  /**
+   * UNA credencial, y **solo los campos que se piden**.
+   *
+   * `keys` no es una optimización: es lo que hace que rellenar un nombre no saque de la
+   * bóveda la contraseña. Al otro lado, pedir algo privado puede exigir la huella; pedir
+   * lo público, no (DISENO §4.2).
+   */
+  async get (id, opts = {}) {
+    return this.#request('get', { id, ...(Array.isArray(opts.keys) ? { keys: opts.keys } : {}) })
+  }
+
+  async put (entry) {
+    return this.#request('put', { entry })
+  }
+
+  /**
+   * CAMBIAR unos campos sin leer la entrada antes. Lo demás se queda como estaba, y la
+   * fusión la hace quien tiene el dato — así guardar un teléfono no saca una contraseña.
+   */
+  async patch (id, changes) {
+    return this.#request('patch', { id, changes })
+  }
+
+  /**
+   * No se puede, y no es una limitación técnica: si la extensión pudiera listar la
+   * bóveda entera, el "pide de a una" no significaría nada (DISENO §2).
+   */
+  /** Buscar por texto en toda la bóveda. Lo público, y con tope (ver `LocalVault`). */
+  async search (q, opts = {}) {
+    return this.#request('search', { q, limit: opts.limit })
+  }
+
+  /**
+   * En qué sitios hay algo guardado, y cuántas entradas en cada uno. Ni un id ni un
+   * nombre: el dominio, que ya viaja en claro para poder emparejar (§5).
+   */
+  async sites () {
+    return this.#request('sites', {})
+  }
+
+  /** Quitar una entrada. La borra quien la tiene, no quien la pide. */
+  async remove (id) {
+    return this.#request('remove', { id })
+  }
+
+  async list () {
+    throw new VaultError(CODES.NO_KEY, 'una bóveda remota no lista: pide de a una')
+  }
+
+  async #request (op, payload) {
+    try {
+      return await this.transport.request(op, payload)
+    } catch (e) {
+      // El transporte puede fallar de muchas formas; hacia arriba solo hay códigos.
+      if (e instanceof VaultError) throw e
+      throw new VaultError(e?.code || CODES.UNREACHABLE, e?.message || 'no hay bóveda al otro lado')
+    }
+  }
+}

package/vault/vendor/passmanager/vault/responder.js

@@ -0,0 +1,192 @@
+// El lado que RESPONDE: la bóveda de verdad (el vault del PC, la app nativa).
+//
+// Es donde vive la política, y por eso está aquí y no repartida por cada aparato:
+// quién puede pedir, qué puede pedir, qué exige aprobación y qué queda anotado. Un
+// aparato que pide no decide nada.
+
+import { isRequest, reply, replyError, REMOTE_OPS, ADMIN_OPS } from '../transport/protocol.js'
+import { ApprovalGate } from './approval.js'
+import { privateKeysOf } from '../fields.js'
+import { projectEntry } from '../model.js'
+import { CODES } from './errors.js'
+
+export class VaultResponder {
+  /**
+   * @param {object} opts
+   *   `client`   cliente de @dotrino/proxy-client conectado e identificado
+   *   `vault`    una bóveda con la CEK (LocalVault desbloqueada)
+   *   `isAllowed(pubkey) -> boolean`  qué aparatos pueden pedir. Por defecto NADIE:
+   *              una bóveda que responde a cualquiera no es una bóveda.
+   *   `needsApproval(op, payload, pubkey) -> boolean|Promise`  qué exige un dedo encima.
+   *              Por defecto: **solo `get`, y solo si lo pedido incluye algo privado**
+   *              (dueño, 2026-08-29). Rellenar un nombre no es sacar un secreto.
+   *   `approve({ op, payload, pubkey }) -> Promise<boolean>`  cómo se pide ese dedo
+   *   `onRequest(record)`  la bitácora
+   *   `admin`  `{ devices(), unlink(pubkey) }` — opcional. Sin esto, un aparato no
+   *            puede administrar nada, que es el valor por defecto correcto.
+   *
+   * **La aprobación es del APARATO, no de cada credencial.** Se pide una vez y vale
+   * mientras esta bóveda siga encendida; apagarla la retira. Es el mismo modelo que
+   * `pair --approval` del vault: una por arranque, sin ventana de tiempo que vigilar.
+   *
+   * No se ata a la conexión a propósito: un service worker se duerme cada poco y
+   * reconecta constantemente, así que «por conexión» sería pedir el dedo todo el rato.
+   * Quien manda es la bóveda, que es la que el usuario apaga cuando quiere cortar.
+   */
+  constructor ({ client, vault, isAllowed, needsApproval, approve, onRequest, encPubOf, admin } = {}) {
+    this.admin = admin || null
+    this.client = client
+    this.vault = vault
+    // La pública de cifrado de cada aparato, para sellarle la respuesta. Abrir lo que
+    // llega es cosa del cliente del pilar (`requireSealed` + `myEncPrivateKey`).
+    this.encPubOf = encPubOf || (() => null)
+    this.isAllowed = isAllowed || (() => false)
+    this.needsApproval = needsApproval || ((op, payload) => this.wantsPrivate(op, payload))
+    this.approve = approve || (async () => false)
+    this.onRequest = onRequest || (() => {})
+    this._handler = null
+    // La puerta es la MISMA que la de la bóveda de dentro de la extensión
+    // (`GuardedVault`): dedupe de simultáneas, el sí recordado, el no nunca. Aquí se
+    // recuerda por APARATO, que es lo que dice §2.0, y vive en memoria — apagar la
+    // bóveda retira lo aprobado, que es el diseño.
+    this.gate = new ApprovalGate({
+      ask: ({ op, payload, pubkey }) => this.approve({ op, payload, pubkey }),
+      scope: ({ pubkey }) => pubkey,
+    })
+  }
+
+  /** Retira la aprobación de un aparato sin apagar la bóveda. */
+  revokeApproval (pubkey) {
+    this.gate.revoke(pubkey || null)
+  }
+
+  isApproved (pubkey) {
+    return this.gate.granted(pubkey)
+  }
+
+  /**
+   * ¿Lo que se pide incluye algo PRIVADO? Es la pregunta que decide si hace falta un dedo
+   * encima, y solo la puede contestar quien tiene la llave: hay que abrir la entrada para
+   * saber qué campos marcó el usuario (§4.2).
+   *
+   * Es **pública** para que una bóveda con su propia política la componga en vez de
+   * reescribirla: el vault del ecosistema, por ejemplo, aprueba por aparato *y* quiere
+   * este criterio encima (`needsApproval(pubkey) && responder.wantsPrivate(op, payload)`).
+   * Sin esto, cada bóveda acabaría con su propia idea de qué es privado.
+   *
+   * Si no se puede abrir, se contesta que **sí**: ante la duda, se pregunta.
+   */
+  async wantsPrivate (op, payload) {
+    if (op !== 'get') return false
+    try {
+      const open = await this.vault.get(payload.id)
+      const privadas = privateKeysOf(open)
+      if (!Array.isArray(payload.keys)) return privadas.size > 0
+      return payload.keys.some(k => privadas.has(k))
+    } catch { return true }
+  }
+
+  start () {
+    if (this._handler) return
+    this._handler = (from, payload, meta) => {
+      this.#handle(payload, meta?.fromPubkey || from, meta).catch(() => {})
+    }
+    this.client.on('message', this._handler)
+  }
+
+  stop () {
+    if (this._handler && this.client.off) this.client.off('message', this._handler)
+    this._handler = null
+  }
+
+  async #send (pubkey, msg) {
+    try {
+      // La respuesta lleva la credencial: se sella al aparato que la pidió, o no sale.
+      const encPub = this.encPubOf(pubkey)
+      if (!encPub) return
+      await this.client.sendSealed([pubkey], msg, { peerEncPub: encPub })
+    } catch { /* el que pidió reintentará */ }
+  }
+
+  async #handle (msg, fromPubkey, meta) {
+    if (!isRequest(msg)) return
+
+    // **Nada sin cifrar entra.** El cliente del pilar abre los sobres y marca
+    // `meta.sealed`; aquí se exige esa marca. Sin ella bastaría con mandar la petición
+    // en claro para saltarse el sellado entero, y el proxio vería qué se pide.
+    if (meta?.sealed !== true) {
+      this.onRequest({ op: msg.op, from: fromPubkey, ts: Date.now(), outcome: 'unsealed' })
+      return
+    }
+
+    const record = { op: msg.op, from: fromPubkey, ts: Date.now() }
+
+    // 1. ¿Es un aparato que conozco? Si no, ni se le contesta qué falló.
+    if (!fromPubkey || !this.isAllowed(fromPubkey)) {
+      this.onRequest({ ...record, outcome: 'denied' })
+      return this.#send(fromPubkey, replyError(msg.rid, CODES.DENIED, 'aparato no autorizado'))
+    }
+
+    // 2. `list` no está en la lista, y esa ausencia es el diseño: si un aparato
+    //    pudiera pedir la bóveda entera, el "de a una" no significaría nada.
+    const esAdmin = ADMIN_OPS.includes(msg.op)
+    if (!REMOTE_OPS.includes(msg.op) && !esAdmin) {
+      this.onRequest({ ...record, outcome: 'denied' })
+      return this.#send(fromPubkey, replyError(msg.rid, CODES.DENIED, 'operación no permitida en remoto'))
+    }
+    if (esAdmin && !this.admin) {
+      this.onRequest({ ...record, outcome: 'denied' })
+      return this.#send(fromPubkey, replyError(msg.rid, CODES.DENIED, 'esta bóveda no se administra en remoto'))
+    }
+
+    try {
+      const payload = msg.payload || {}
+
+      // Administrar SIEMPRE se aprueba, y aparte: retirar un aparato desde otro
+      // aparato es tan delicado como entregar una contraseña, y en el otro sentido.
+      // Que el aparato ya esté aprobado para pedir credenciales no le da esto.
+      if (esAdmin) {
+        const ok = await this.approve({ op: msg.op, payload, pubkey: fromPubkey, admin: true })
+        if (!ok) {
+          this.onRequest({ ...record, outcome: 'refused' })
+          return this.#send(fromPubkey, replyError(msg.rid, CODES.NOT_APPROVED, 'no aprobado'))
+        }
+        const result = msg.op === 'devices'
+          ? await this.admin.devices()
+          : await this.admin.unlink(payload.pubkey)
+        this.onRequest({ ...record, outcome: 'served' })
+        return this.#send(fromPubkey, reply(msg.rid, result ?? null))
+      }
+
+      if (await this.needsApproval(msg.op, payload, fromPubkey)) {
+        const ok = await this.gate.allow({ op: msg.op, payload, pubkey: fromPubkey })
+        if (!ok) {
+          this.onRequest({ ...record, outcome: 'refused' })
+          return this.#send(fromPubkey, replyError(msg.rid, CODES.NOT_APPROVED, 'no aprobado'))
+        }
+      }
+
+      let result
+      switch (msg.op) {
+        case 'find': result = await this.vault.find(payload.url); break
+        // Solo lo pedido sale por el cable: sin este recorte, rellenar un nombre mandaba
+        // la entrada entera —contraseña incluida— al aparato que preguntó.
+        case 'get':
+          result = projectEntry(await this.vault.get(payload.id),
+            Array.isArray(payload.keys) ? payload.keys : null)
+          break
+        case 'put': result = await this.vault.put(payload.entry); break
+        case 'patch': result = await this.vault.patch(payload.id, payload.changes); break
+        case 'sites': result = await this.vault.sites(); break
+        case 'search': result = await this.vault.search(payload.q, { limit: payload.limit }); break
+        case 'remove': result = await this.vault.remove(payload.id); break
+      }
+
+      this.onRequest({ ...record, outcome: 'served', id: payload.id })
+      await this.#send(fromPubkey, reply(msg.rid, result ?? null))
+    } catch (e) {
+      this.onRequest({ ...record, outcome: 'error', code: e?.code })
+      await this.#send(fromPubkey, replyError(msg.rid, e?.code || 'error', e?.message))
+    }
+  }
+}