@xiotbox/e2e-channel 0.1.0

package/README.md

@@ -0,0 +1,165 @@
+<p align="center">
+  <img src="docs/assets/xiotbox-logo.png" alt="XiotBox" width="112" />
+</p>
+
+<h1 align="center">XiotBox E2E Secure Channel</h1>
+
+<p align="center">
+  <strong>A reusable end-to-end encrypted relay protocol for XiotBox runtimes and clients.</strong><br />
+  TypeScript/Node implementation built on standard cryptographic primitives with zero runtime dependencies beyond Node.js crypto.
+</p>
+
+<p align="center">
+  <img alt="Package" src="https://img.shields.io/badge/npm-%40xiotbox%2Fe2e--channel-CB3837" />
+  <img alt="Version" src="https://img.shields.io/badge/version-0.1.0-1f6feb" />
+  <img alt="TypeScript" src="https://img.shields.io/badge/TypeScript-5.6%2B-3178C6" />
+  <img alt="Crypto" src="https://img.shields.io/badge/Crypto-X25519%20%7C%20HKDF%20%7C%20AES--256--GCM-2ea043" />
+  <img alt="License" src="https://img.shields.io/badge/License-MIT-555" />
+</p>
+
+<p align="center">
+  English · <a href="README.zh-CN.md">Simplified Chinese</a>
+</p>
+
+`@xiotbox/e2e-channel` provides the shared secure-channel implementation used when XiotBox needs to relay traffic through infrastructure that should not be able to read the application payload.
+
+The protocol is transport-agnostic: Gateway can carry encrypted frames over an existing relay path while endpoint identity, key agreement, encryption, and message authenticity remain end-to-end concerns.
+
+---
+
+## Why this exists
+
+XiotBox increasingly connects clients, AI Hosts, DSH/OpenClaw runtimes, device services, and remote control surfaces across machines and networks.
+
+A relay is useful for reachability, but it should not automatically become trusted with every conversation, credential, code fragment, or local device payload that crosses it.
+
+The secure-channel model is therefore:
+
+```text
+Endpoint A
+   │
+   │ encrypt + authenticate
+   ▼
+XiotBox Gateway / relay
+   │ sees ciphertext
+   ▼
+Endpoint B
+   │ decrypt + verify
+   ▼
+Application payload
+```
+
+Gateway remains responsible for routing and connection ownership. This package is responsible for the end-to-end cryptographic envelope.
+
+---
+
+## Package
+
+```text
+@xiotbox/e2e-channel
+```
+
+Current package metadata:
+
+```text
+version: 0.1.0
+runtime: Node.js
+language: TypeScript
+license: MIT
+runtime dependencies: node:crypto only
+```
+
+---
+
+## Cryptographic direction
+
+The current protocol is built from standard primitives:
+
+- X25519 for ephemeral key agreement;
+- HKDF for key derivation;
+- AES-256-GCM for authenticated encryption;
+- Ed25519 for endpoint identity signatures.
+
+The repository should not invent custom cryptographic primitives. Protocol evolution should remain explicit, versioned, and reviewable.
+
+Full protocol specification:
+
+```text
+docs/e2e-secure-channel.md
+```
+
+---
+
+## Current consumers
+
+The package is designed as shared infrastructure rather than a DSH-specific implementation.
+
+Known integration direction includes:
+
+- `dsh-channel-xiotbox` secure tunnel mode;
+- `openclaw-channel-xiotbox` and future runtime integrations where the same secure relay model is appropriate;
+- future XiotBox client/runtime channels that need relay confidentiality without trusting the relay with plaintext.
+
+A consumer may choose a different transport while reusing the same secure-channel contract.
+
+---
+
+## Build and test
+
+```bash
+npm install
+npm run typecheck
+npm test
+```
+
+The test command builds the package and executes the Node.js test suite.
+
+Build only:
+
+```bash
+npm run build
+```
+
+Output is emitted under `lib/` according to the package TypeScript configuration.
+
+---
+
+## Security boundaries
+
+This package does **not** decide:
+
+- which user owns a device;
+- which runtime a conversation belongs to;
+- whether a caller may execute a tool;
+- whether a workspace is readable/writable/executable;
+- whether an endpoint should be trusted in the first place.
+
+Those decisions belong to Gateway, runtime policy, trust configuration, and governance layers.
+
+Encryption must not be mistaken for authorization.
+
+---
+
+## Trust model
+
+Secure channels require endpoint identity handling in addition to encryption.
+
+Integrations may use pinned identity keys or TOFU-style enrollment depending on the product flow, but the resulting trust decision must remain explicit and inspectable. A relay delivering bytes successfully is not proof that the peer is the intended endpoint.
+
+---
+
+## Design principles
+
+1. **Use standard primitives, not bespoke cryptography.**
+2. **Treat the relay as a router, not an application-data reader.**
+3. **Keep encryption separate from authorization.**
+4. **Make identity and trust decisions explicit.**
+5. **Keep the package reusable across runtimes and transports.**
+6. **Version protocol changes deliberately.**
+7. **Fail closed on authentication or integrity errors.**
+
+---
+
+## Current direction
+
+`xiotbox-e2e-ts` is the shared cryptographic seam for XiotBox remote-runtime channels. Its job is intentionally narrow: give higher-level integrations a small, auditable secure-channel implementation so DSH, OpenClaw, clients, and future AI Hosts do not each invent their own incompatible encryption layer.

package/README.zh-CN.md

@@ -0,0 +1,163 @@
+<p align="center">
+  <img src="docs/assets/xiotbox-logo.png" alt="XiotBox" width="112" />
+</p>
+
+<h1 align="center">XiotBox E2E Secure Channel</h1>
+
+<p align="center">
+  <strong>XiotBox Runtime 与客户端之间可复用的端到端加密中继协议。</strong><br />
+  基于 TypeScript/Node 和标准密码学原语，运行时只依赖 Node.js 自带 crypto。
+</p>
+
+<p align="center">
+  <img alt="Package" src="https://img.shields.io/badge/npm-%40xiotbox%2Fe2e--channel-CB3837" />
+  <img alt="Version" src="https://img.shields.io/badge/version-0.1.0-1f6feb" />
+  <img alt="TypeScript" src="https://img.shields.io/badge/TypeScript-5.6%2B-3178C6" />
+  <img alt="Crypto" src="https://img.shields.io/badge/Crypto-X25519%20%7C%20HKDF%20%7C%20AES--256--GCM-2ea043" />
+  <img alt="License" src="https://img.shields.io/badge/License-MIT-555" />
+</p>
+
+<p align="center">
+  <a href="README.md">English</a> · 简体中文
+</p>
+
+`@xiotbox/e2e-channel` 是 XiotBox 统一的安全通道实现，用于那些“必须经过 Gateway/中继，但中继本身不应该看到明文”的场景。
+
+它的职责很窄：提供端到端加密、身份签名和完整性保护。设备属于谁、Runtime 属于哪个用户、是否允许执行工具，这些都不是加密库该决定的。
+
+---
+
+## 为什么需要这一层
+
+XiotBox 的客户端、AI Host、DSH、OpenClaw 和设备服务越来越多地运行在不同机器和网络里。
+
+Gateway 解决“怎么找到对方、怎么把数据送过去”，但如果所有内容都在 Gateway 解密，就意味着会话、代码、凭据和本地设备数据都把 Gateway 变成了一个过度信任点。
+
+目标结构是：
+
+```text
+端点 A
+   │ 加密 + 身份认证
+   ▼
+Gateway / Relay
+   │ 只看到密文
+   ▼
+端点 B
+   │ 解密 + 验证
+   ▼
+应用数据
+```
+
+Gateway 继续负责路由，E2E Channel 负责端到端密码学边界。
+
+---
+
+## 包信息
+
+```text
+@xiotbox/e2e-channel
+```
+
+当前：
+
+```text
+version: 0.1.0
+runtime: Node.js
+language: TypeScript
+license: MIT
+runtime dependencies: node:crypto only
+```
+
+---
+
+## 密码学方案
+
+当前协议使用：
+
+- X25519：临时密钥协商；
+- HKDF：密钥派生；
+- AES-256-GCM：认证加密；
+- Ed25519：端点身份签名。
+
+这里的原则非常明确：**不自己发明密码算法。**
+
+完整协议：
+
+```text
+docs/e2e-secure-channel.md
+```
+
+---
+
+## 谁在使用它
+
+这不是 DSH 专用库，而是 XiotBox 的共享安全协议层。
+
+当前/规划中的消费者包括：
+
+- `dsh-channel-xiotbox` 的安全隧道；
+- `openclaw-channel-xiotbox` 等需要同类安全中继的 Runtime；
+- 未来 XiotBox Client / AI Host 的安全远程通道。
+
+底层传输可以是不同的，只要上层需要同一套端到端安全语义，就不应该再造一份加密实现。
+
+---
+
+## 构建和测试
+
+```bash
+npm install
+npm run typecheck
+npm test
+```
+
+只构建：
+
+```bash
+npm run build
+```
+
+---
+
+## 它不负责什么
+
+E2E Channel 不负责：
+
+- 用户和设备归属；
+- Runtime / conversation ownership；
+- Tool 权限；
+- Workspace 读写执行权限；
+- 谁可以获得管理员能力；
+- 业务身份和审批。
+
+这些属于 Gateway、Runtime policy、MCP 和治理系统。
+
+**加密不等于授权。** 一条连接可以是强加密的，同时连接的人仍然可能没有执行某个动作的权限。
+
+---
+
+## 身份与信任
+
+只有“加密成功”还不够，还需要确认对端到底是谁。
+
+不同产品流程可以使用 pinned identity 或 TOFU，但最终的信任结果必须是明确、可检查的。Gateway 能把包送到某个连接，不等于这个连接天然就是用户想要的那台设备。
+
+---
+
+## 核心原则
+
+1. **只使用标准密码学原语。**
+2. **中继负责送数据，不默认拥有明文。**
+3. **加密和授权分离。**
+4. **身份和 trust decision 必须明确。**
+5. **协议应被 DSH、OpenClaw、客户端等多种消费者复用。**
+6. **协议升级必须有版本和兼容边界。**
+7. **身份、完整性或认证失败时 fail closed。**
+
+---
+
+## 当前方向
+
+`xiotbox-e2e-ts` 会成为 XiotBox 远程 Runtime 安全通信的共享密码学接缝。
+
+它不需要做成一个庞大的安全平台。恰恰相反，这一层越小、越清晰、越容易审计越好。这样未来增加新的 Agent Runtime 时，接入同一套安全协议即可，而不是每个团队重新发明一次“我们的 AES 包装方式”。

package/docs/e2e-secure-channel.md

@@ -0,0 +1,177 @@
+# XiotBox E2E Secure Channel — Protocol Specification v1
+
+Status: **Implemented** (TypeScript/Node + Dart client; plugin-side DSH tunnel
+integrated). Cross-language implementations must match this document exactly —
+any change here is a breaking wire change.
+
+## 1. Purpose
+
+The XiotBox Gateway relay (`relay_service.py`) is an opaque byte pipe: it
+forwards frames between a host agent (DSH, OpenClaw, future Codex / Claude
+Code runtimes) and a XiotBox client without interpreting them. The E2E Secure
+Channel sits **between an application protocol and that relay**, providing
+end-to-end security against the Gateway itself (its operator, a compromise, or
+a legal demand):
+
+- **Confidentiality** — the Gateway only ever sees ciphertext frames.
+- **Integrity** — AES-256-GCM AEAD rejects any modified frame.
+- **Anti-replay / anti-reorder** — per-direction sequence counters bound in
+  the AAD.
+- **Forward secrecy** — a fresh ephemeral X25519 key pair per channel; a
+  leaked session key never affects other channels.
+- **Peer authentication** — Ed25519 identity signatures over the full
+  handshake transcript, pinned TOFU by each application.
+
+## 2. Transport assumptions
+
+- The relay delivers **JSON frames**, base64-encoded as the relay `payload`
+  field (existing DERP wire format, unchanged).
+- One SecureChannel instance = one relay channel. The session key lives in
+  memory only and is destroyed on close.
+- All multi-byte values are **big-endian**; all binary payloads are base64.
+
+## 3. Identity & registration
+
+Every device (host) owns one long-term identity, shared across all its agent
+channels:
+
+| Item | Algorithm | Purpose |
+| --- | --- | --- |
+| Long-term X25519 keypair | X25519 | `kid` in the handshake; registered with Lite via `POST /openclaw/devices/e2e/peer_key` |
+| Ed25519 identity keypair | Ed25519 | signs the handshake transcript; fingerprint shown to the user for out-of-band verification |
+
+- Key id: `sha256(pub)[:16]` hex.
+- Identity fingerprint: full `sha256(SPKI-DER(pub))` hex.
+- The **client** registers its own key + identity via
+  `POST /openclaw/bots/{bot_id}/e2e/client_key` and learns the host's
+  `peer_key_id`/`peer_public_key` from the response.
+- The **host** learns the client's `client_key_id` and
+  `client_identity_public_key` from the `peer_key` registration response.
+- Registration flows through the Gateway, which proxies to Lite. Lite's
+  device record is the trust anchor; see §8 for residual risks.
+
+## 4. Handshake (once per relay channel)
+
+The client is always the **initiator**; the host plugin is the **responder**.
+
+```
+C → P:  {t:'hello', v:1, pub: <eph X25519 pub b64>, kid: <C key id>, nonce: <16B hex>}
+P → C:  {t:'hello_ack', v:1, pub: <eph X25519 pub b64>, kid: <P key id>, nonce: <16B hex>}
+C → P:  {t:'ident', v:1, id: <C Ed25519 pub raw b64>, fp: <fingerprint>, sig: <sig b64>}
+P → C:  {t:'ident_ack', v:1, id: <P Ed25519 pub raw b64>, fp: <fingerprint>, sig: <sig b64>}
+```
+
+Both sides then derive:
+
+```
+shared       = ECDH(my_eph_priv, peer_eph_pub)
+session_key  = HKDF-SHA256(shared, salt=channel_id, info='xiotbox-e2e|v=1|stream', 32)
+```
+
+### 4.1 Validations
+
+- `pub` must be exactly 32 bytes; `kid` and `nonce` non-empty.
+- `kid` is checked against the peer's **registered** key id when known;
+  mismatch → close with `e2e_peer_kid_mismatch`.
+- The `ident`/`ident_ack` signature is verified over the **handshake
+  transcript**; the claimed identity is then checked against the
+  application's trust policy (TOFU pin, registered identity, …). Failure →
+  close with `e2e_identity_sig_invalid` / `e2e_peer_identity_mismatch` /
+  `e2e_peer_identity_changed`.
+- Handshake frames are plaintext but carry no secrets (public keys + nonces).
+- Timeout: if the handshake does not complete in 10 s (configurable), the
+  channel closes with `e2e_handshake_timeout`.
+
+### 4.2 Handshake transcript (canonical, role-agnostic)
+
+Both peers must compute the **identical string** for the same `dir`, so the
+field order is canonical (`c_` = client/initiator, `p_` = plugin/responder):
+
+```
+xiotbox-e2e|v=1|channel={channel_id}|dir={dir}|c_eph={C_eph_pub_b64}|p_eph={P_eph_pub_b64}|
+c_kid={C_key_id}|p_kid={P_key_id}|c_nonce={C_nonce}|p_nonce={P_nonce}
+```
+
+`dir` is `c2p` for the client's claim and `p2c` for the plugin's claim.
+
+## 5. Frame encryption
+
+After the handshake, every application frame is wrapped:
+
+```
+{t:'enc', v:1, iv: <12B b64>, tag: <16B b64>, ct: <b64>}
+```
+
+- `ct` = AES-256-GCM ciphertext of the **application frame JSON**.
+- `tag` = the GCM authentication tag (16 bytes).
+- AAD (authenticated, not encrypted):
+
+```
+xiotbox-e2e|v=1|stream|{channel_id}|{dir}|{seq}
+```
+
+  where `dir` is the direction the frame **travels** (`c2p` client→plugin,
+  `p2c` plugin→client) and `seq` is a per-direction counter starting at 1,
+  incremented per encrypted frame. This binds every frame to its channel,
+  direction and position → replay, reorder and cross-channel injection all
+  fail tag verification (`e2e_frame_auth_failed`).
+
+### 5.1 Plaintext control frames
+
+Application keepalives (e.g. the tunnel's `{k:'ping'}` / `{k:'pong'}`) stay
+outside the E2E layer and are relayed plaintext: they carry no sensitive
+content and avoiding per-keepalive encryption keeps heartbeats cheap.
+
+## 6. Failure semantics
+
+| Condition | Close reason |
+| --- | --- |
+| Encrypted frame before handshake | `enc_before_handshake` |
+| Business frame in plaintext during handshake | `e2e_handshake_incomplete` |
+| Business frame in plaintext after handshake (required mode) | `e2e_plaintext_rejected` |
+| AEAD verification failure | `e2e_frame_auth_failed` |
+| Peer key id mismatch | `e2e_peer_kid_mismatch` |
+| Identity signature invalid | `e2e_identity_sig_invalid` |
+| Identity rejected by trust policy | `e2e_peer_identity_mismatch` / `e2e_peer_identity_changed` |
+| Handshake not completed in time | `e2e_handshake_timeout` |
+
+Any close tears down the whole relay channel and destroys the session key.
+
+## 7. Implementations
+
+| Platform | Location | Status |
+| --- | --- | --- |
+| TypeScript / Node (agents) | `src/` of this repo — `crypto.ts`, `secure-channel.ts` | ✅ tested |
+| Dart (Flutter client) | `xiotbox-client-ui/lib/core/crypto/secure_channel.dart` | ✅ tested |
+| Consumers | `dsh-channel-xiotbox` (DSH web tunnel) | ✅ integrated |
+| Future: Python / Rust (e.g. Claude Code agents) | — | open |
+
+All implementations must pass equivalent tests: handshake round-trip, tamper
+rejection, replay rejection, cross-channel rejection, identity policy
+rejection, timeout.
+
+## 8. Known residual risks (be honest with customers)
+
+1. **TOFU on first connection** — a MITM on the *first* handshake (before any
+   pin exists) can substitute its own identity. Mitigation: display the
+   fingerprint in the client UI and verify it out-of-band on the host
+   (SSH-style). This is the single most important follow-up.
+2. **Registration trust anchor** — key registration is proxied through the
+   Gateway to Lite. A Gateway that also compromises Lite's device records can
+   substitute keys at registration time; out-of-band fingerprint verification
+   is the countermeasure.
+3. **`e2e: off` downgrade path** — kept for fleet compatibility; must be
+   removed after all hosts and clients are upgraded.
+4. **No mid-session key rotation** — session keys live for one channel. For
+   very long-lived channels (>1 GB transferred or >10 min), add rotation on
+   the same AAD/seq machinery (documented as optional follow-up).
+5. **No formal verification / no third-party audit yet** — the construction
+   uses standard primitives in standard patterns (cf. Noise / WireGuard /
+   TLS 1.3), but a professional audit is required before commercial
+   "audited" claims.
+
+## 9. Versioning
+
+- `v` field = protocol version, currently 1. Frame/AAD/transcript strings
+  embed `v=1` for domain separation.
+- Breaking changes bump `v`; implementations must reject unknown versions.

package/lib/crypto.d.ts

@@ -0,0 +1,126 @@
+/**
+ * XiotBox E2E Secure Channel — generic cryptographic primitives.
+ *
+ * Application-agnostic building blocks for the `xiotbox-e2e` protocol:
+ * X25519 key agreement, HKDF-SHA256 session-key derivation, AES-256-GCM
+ * frame sealing, Ed25519 identity signing, and per-device key persistence.
+ *
+ * Nothing here knows about DSH, OpenClaw, tunnels or chat: any agent channel
+ * that relays opaque bytes through the XiotBox Gateway can reuse this module.
+ * The wire protocol is documented in `docs/e2e-secure-channel.md`.
+ */
+import crypto from 'node:crypto';
+export declare const E2E_PROTOCOL = "xiotbox-e2e";
+export declare const E2E_VERSION = 1;
+export declare const E2E_MODE_STREAM = "stream";
+/** Ed25519 SPKI DER prefix: SEQUENCE { SEQUENCE { OID 1.3.101.112 }, BIT STRING } */
+export declare const ED25519_SPKI_PREFIX: Buffer<ArrayBuffer>;
+export interface X25519Keypair {
+    priv: Buffer;
+    pub: Buffer;
+    keyId: string;
+}
+export interface Ed25519Identity {
+    privKey: crypto.KeyObject;
+    pubRaw: Buffer;
+    pubDer: Buffer;
+    fingerprint: string;
+}
+export interface StoredDeviceKeys {
+    v: 1;
+    x25519: {
+        priv_b64: string;
+        pub_b64: string;
+        key_id: string;
+    };
+    identity: {
+        priv_der_b64: string;
+        pub_der_b64: string;
+        fingerprint: string;
+    };
+}
+export declare function x25519Keypair(): {
+    priv: Buffer;
+    pub: Buffer;
+};
+export declare function x25519Shared(priv: Buffer, pub: Buffer): Buffer;
+export declare function b64e(value: Buffer): string;
+export declare function b64d(value: unknown): Buffer | undefined;
+/** Key id: first 16 hex chars of SHA-256(public key) — matches OpenClaw / client. */
+export declare function computeKeyId(pubRaw: Buffer): string;
+/** Identity fingerprint: full SHA-256 hex of the SPKI DER public key. */
+export declare function computeIdentityFingerprint(pubDer: Buffer): string;
+/**
+ * Human-readable fingerprint for out-of-band verification: uppercase hex in
+ * groups of 4, e.g. `A1B2 C3D4 E5F6 …`. Host logs and client UIs must format
+ * identically so a user can compare them.
+ */
+export declare function formatFingerprint(fingerprint: string): string;
+/** Extract the raw 32-byte Ed25519 public key from SPKI DER. */
+export declare function ed25519RawFromDer(pubDer: Buffer): Buffer;
+/** Normalize a peer Ed25519 public key (raw 32B or SPKI DER 44B) to raw 32B. */
+export declare function normalizeEd25519Pub(value: Buffer): Buffer | undefined;
+/**
+ * Derive the per-channel session key.
+ *   session_key = HKDF-SHA256(ECDH(eph), salt=channel_id, info='xiotbox-e2e|v=1|stream')
+ */
+export declare function deriveSessionKey(shared: Buffer, channelId: string): Buffer;
+/**
+ * AAD bound to every encrypted frame:
+ *   'xiotbox-e2e|v=1|stream|{channel_id}|{dir}|{seq}'
+ * `dir` is the direction the frame travels ('c2p' client→plugin, 'p2c' plugin→client).
+ */
+export declare function buildFrameAad(channelId: string, dir: 'c2p' | 'p2c', seq: number): Buffer;
+/**
+ * Handshake transcript signed by each side's Ed25519 identity key.
+ *
+ * Fields use a canonical role-agnostic order (`c_` = client/initiator side,
+ * `p_` = plugin/responder side) so both peers compute the identical string
+ * for the same `dir`, regardless of which side is signing.
+ */
+export declare function buildHandshakeTranscript(opts: {
+    channelId: string;
+    dir: 'c2p' | 'p2c';
+    cEphPubB64: string;
+    pEphPubB64: string;
+    cKid: string;
+    pKid: string;
+    cNonce: string;
+    pNonce: string;
+}): Buffer;
+/**
+ * Registration identity claim, mirroring the OpenClaw `ocid|...` canonical
+ * format so Lite/clients that already verify bot identity claims accept the
+ * same signature scheme.
+ */
+export declare function buildRegistrationSigPayload(opts: {
+    deviceId: string;
+    peerPubB64: string;
+    keyId: string;
+    ts: string;
+    nonce: string;
+}): Buffer;
+/** AES-256-GCM seal: returns { iv, tag, ct } all base64 for wire transport. */
+export declare function sealFrame(key: Buffer, plaintext: Buffer, aad: Buffer): {
+    iv: string;
+    tag: string;
+    ct: string;
+};
+/** AES-256-GCM open: returns the plaintext Buffer, or undefined on auth failure. */
+export declare function openFrame(key: Buffer, frame: {
+    iv: string;
+    tag: string;
+    ct: string;
+}, aad: Buffer): Buffer | undefined;
+export declare function generateEd25519Identity(): Ed25519Identity;
+export declare function signMessage(privKey: crypto.KeyObject, message: Buffer): Buffer;
+/** Verify an Ed25519 signature against a raw (32B) or SPKI DER (44B) public key. */
+export declare function verifyMessage(pubKey: Buffer, message: Buffer, signature: Buffer): boolean;
+/** Default key directory: `~/.xiotbox/e2e`. Consumers may pass their own. */
+export declare function defaultE2EKeyDir(): string;
+export declare function deviceKeyPath(keyDir: string, deviceId: string): string;
+/** Load persisted keys for a device, creating them on first run. */
+export declare function loadOrCreateDeviceKeys(deviceId: string, keyDir?: string, log?: (level: 'debug' | 'info' | 'warn', message: string) => void): {
+    keypair: X25519Keypair;
+    identity: Ed25519Identity;
+};