@7h3/protocol 0.1.2 → 0.5.0

package/src/webhookBinding.ts

@@ -0,0 +1,115 @@
+import {
+  signCanonicalPayloadEd25519,
+  verifyCanonicalPayloadEd25519,
+  signCanonicalPayloadHmac,
+  verifyCanonicalPayloadHmac,
+  generateEd25519KeypairBase64Url,
+} from './protocol'
+
+export const WEBHOOK_SIG_HEADER = 'x-7h3-sig'
+export const WEBHOOK_TS_HEADER = 'x-7h3-ts'
+export const WEBHOOK_DEFAULT_TTL_MS = 300_000  // 5 minutes
+
+// What gets signed: "${timestampMs}.${rawBody}" — binds time AND content
+function webhookSigningPayload(timestampMs: number, body: string): string {
+  return `${timestampMs}.${body}`
+}
+
+export interface WebhookSignOptions {
+  privateKey: string  // Ed25519 PKCS8 base64url
+  ttlMs?: number      // default 5 min
+}
+
+export interface WebhookSignHmacOptions {
+  secret: string
+  ttlMs?: number
+}
+
+export interface WebhookVerifyOptions {
+  publicKey: string   // Ed25519 SPKI base64url
+  maxAgeMs?: number   // default 5 min
+}
+
+export interface WebhookVerifyHmacOptions {
+  secret: string
+  maxAgeMs?: number
+}
+
+export interface WebhookHeaders {
+  [WEBHOOK_SIG_HEADER]: string
+  [WEBHOOK_TS_HEADER]: string
+}
+
+// Sign a webhook payload with Ed25519
+export async function signWebhook(
+  payload: string | Uint8Array,
+  opts: WebhookSignOptions
+): Promise<WebhookHeaders> {
+  const body = typeof payload === 'string' ? payload : new TextDecoder().decode(payload)
+  const timestampMs = Date.now()
+  const signingPayload = webhookSigningPayload(timestampMs, body)
+  const sig = await signCanonicalPayloadEd25519(signingPayload, opts.privateKey)
+  return { [WEBHOOK_SIG_HEADER]: sig, [WEBHOOK_TS_HEADER]: String(timestampMs) }
+}
+
+// Sign with HMAC shared secret
+export async function signWebhookHmac(
+  payload: string | Uint8Array,
+  opts: WebhookSignHmacOptions
+): Promise<WebhookHeaders> {
+  const body = typeof payload === 'string' ? payload : new TextDecoder().decode(payload)
+  const timestampMs = Date.now()
+  const signingPayload = webhookSigningPayload(timestampMs, body)
+  const sig = await signCanonicalPayloadHmac(signingPayload, opts.secret)
+  return { [WEBHOOK_SIG_HEADER]: sig, [WEBHOOK_TS_HEADER]: String(timestampMs) }
+}
+
+// Verify Ed25519 webhook signature
+export async function verifyWebhook(
+  payload: string | Uint8Array,
+  headers: WebhookHeaders | Record<string, string>,
+  opts: WebhookVerifyOptions
+): Promise<boolean> {
+  const body = typeof payload === 'string' ? payload : new TextDecoder().decode(payload)
+  const sig = headers[WEBHOOK_SIG_HEADER]
+  const tsStr = headers[WEBHOOK_TS_HEADER]
+  if (!sig || !tsStr) return false
+  const ts = Number(tsStr)
+  if (!Number.isFinite(ts)) return false
+  const maxAge = opts.maxAgeMs ?? WEBHOOK_DEFAULT_TTL_MS
+  if (Date.now() - ts > maxAge) return false
+  const signingPayload = webhookSigningPayload(ts, body)
+  return verifyCanonicalPayloadEd25519(signingPayload, sig, opts.publicKey)
+}
+
+// Verify HMAC webhook signature
+export async function verifyWebhookHmac(
+  payload: string | Uint8Array,
+  headers: WebhookHeaders | Record<string, string>,
+  opts: WebhookVerifyHmacOptions
+): Promise<boolean> {
+  const body = typeof payload === 'string' ? payload : new TextDecoder().decode(payload)
+  const sig = headers[WEBHOOK_SIG_HEADER]
+  const tsStr = headers[WEBHOOK_TS_HEADER]
+  if (!sig || !tsStr) return false
+  const ts = Number(tsStr)
+  if (!Number.isFinite(ts)) return false
+  const maxAge = opts.maxAgeMs ?? WEBHOOK_DEFAULT_TTL_MS
+  if (Date.now() - ts > maxAge) return false
+  const signingPayload = webhookSigningPayload(ts, body)
+  return verifyCanonicalPayloadHmac(signingPayload, sig, opts.secret)
+}
+
+// Parse and verify in one call, throws on failure
+export async function consumeWebhook<T = unknown>(
+  payload: string,
+  headers: Record<string, string>,
+  opts: WebhookVerifyOptions
+): Promise<T> {
+  const valid = await verifyWebhook(payload, headers, opts)
+  if (!valid) throw new Error('7h3: webhook signature verification failed')
+  return JSON.parse(payload) as T
+}
+
+// Re-export key generation for convenience
+export { generateEd25519KeypairBase64Url }

package/src/wsBinding.test.ts

@@ -0,0 +1,221 @@
+import { describe, it, expect, vi } from 'vitest'
+import { wrapWebSocket, generateEd25519KeypairBase64Url, type WebSocketLike } from './wsBinding'
+import { signEnvelopeEd25519, createEnvelope, type ProtocolEnvelope } from './protocol'
+import { createStaticKeyRegistry } from './keyRegistry'
+
+// Mock WebSocket class that buffers sent messages and lets you inject received messages
+class MockWebSocket implements WebSocketLike {
+  public sent: string[] = []
+  private messageHandlers: Array<(e: { data: string }) => void> = []
+  private closeHandlers: Array<() => void> = []
+  readyState = 1
+
+  send(data: string): void {
+    this.sent.push(data)
+  }
+
+  addEventListener(event: string, handler: (...args: any[]) => void): void {
+    if (event === 'message') {
+      this.messageHandlers.push(handler as (e: { data: string }) => void)
+    } else if (event === 'close') {
+      this.closeHandlers.push(handler as () => void)
+    }
+  }
+
+  removeEventListener(event: string, handler: (...args: unknown[]) => void): void {
+    if (event === 'message') {
+      const idx = this.messageHandlers.indexOf(handler as any)
+      if (idx !== -1) this.messageHandlers.splice(idx, 1)
+    } else if (event === 'close') {
+      const idx = this.closeHandlers.indexOf(handler as any)
+      if (idx !== -1) this.closeHandlers.splice(idx, 1)
+    }
+  }
+
+  // Inject a received message
+  receive(data: string): void {
+    for (const h of this.messageHandlers) h({ data })
+  }
+
+  close(): void {
+    for (const h of this.closeHandlers) h()
+  }
+}
+
+describe('wrapWebSocket', () => {
+  it('send() produces a signed JSON frame', async () => {
+    const keypair = await generateEd25519KeypairBase64Url()
+    const ws = new MockWebSocket()
+    const registry = createStaticKeyRegistry({ 'agent-A': keypair.publicKey })
+
+    const pws = wrapWebSocket(ws, {
+      privateKey: keypair.privateKey,
+      sender: 'agent-A',
+      keyRegistry: registry,
+    })
+
+    await pws.send({ hello: 'world' })
+
+    expect(ws.sent).toHaveLength(1)
+    const frame = JSON.parse(ws.sent[0]) as ProtocolEnvelope
+    expect(frame.header.sender).toBe('agent-A')
+    expect(frame.signature).toBeDefined()
+    expect(frame.signature?.alg).toBe('ED25519')
+    expect(frame.body.intent).toBe('TASK')
+    expect(frame.body.content).toBe(JSON.stringify({ hello: 'world' }))
+  })
+
+  it('incoming signed frame calls onMessage handler', async () => {
+    const keypair = await generateEd25519KeypairBase64Url()
+    const ws = new MockWebSocket()
+    const registry = createStaticKeyRegistry({ 'agent-B': keypair.publicKey })
+
+    const pws = wrapWebSocket(ws, {
+      privateKey: keypair.privateKey,
+      sender: 'agent-A',
+      keyRegistry: registry,
+    })
+
+    const received: Array<{ payload: unknown; envelope: ProtocolEnvelope }> = []
+    pws.onMessage((payload, envelope) => received.push({ payload, envelope }))
+
+    // Create a valid signed frame from agent-B
+    const envelope = createEnvelope({
+      sender: 'agent-B',
+      intent: 'TASK',
+      content: JSON.stringify({ ping: true }),
+      ttlMs: 30_000,
+    })
+    const signed = await signEnvelopeEd25519(envelope, keypair.privateKey)
+
+    // Wait for async message processing
+    await new Promise<void>(resolve => {
+      pws.onMessage(() => resolve())
+      ws.receive(JSON.stringify(signed))
+    })
+
+    expect(received).toHaveLength(1)
+    expect(received[0].payload).toEqual({ ping: true })
+    expect(received[0].envelope.header.sender).toBe('agent-B')
+  })
+
+  it('tampered frame calls onVerifyFail', async () => {
+    const keypair = await generateEd25519KeypairBase64Url()
+    const ws = new MockWebSocket()
+    const registry = createStaticKeyRegistry({ 'agent-B': keypair.publicKey })
+
+    const pws = wrapWebSocket(ws, {
+      privateKey: keypair.privateKey,
+      sender: 'agent-A',
+      keyRegistry: registry,
+    })
+
+    const errors: Error[] = []
+    pws.onVerifyFail((err) => errors.push(err))
+
+    // Create a valid signed frame, then tamper with body content
+    const envelope = createEnvelope({
+      sender: 'agent-B',
+      intent: 'TASK',
+      content: 'original content',
+      ttlMs: 30_000,
+    })
+    const signed = await signEnvelopeEd25519(envelope, keypair.privateKey)
+    // Tamper with content after signing
+    const tampered = { ...signed, body: { ...signed.body, content: 'tampered content' } }
+
+    await new Promise<void>(resolve => {
+      pws.onVerifyFail(() => resolve())
+      ws.receive(JSON.stringify(tampered))
+    })
+
+    expect(errors).toHaveLength(1)
+    expect(errors[0].message).toContain('invalid signature')
+  })
+
+  it('unknown sender calls onVerifyFail', async () => {
+    const keypair = await generateEd25519KeypairBase64Url()
+    const ws = new MockWebSocket()
+    // Registry has no entry for 'unknown-agent'
+    const registry = createStaticKeyRegistry({})
+
+    const pws = wrapWebSocket(ws, {
+      privateKey: keypair.privateKey,
+      sender: 'agent-A',
+      keyRegistry: registry,
+    })
+
+    const errors: Error[] = []
+    pws.onVerifyFail((err) => errors.push(err))
+
+    const envelope = createEnvelope({
+      sender: 'unknown-agent',
+      intent: 'TASK',
+      content: 'hello',
+      ttlMs: 30_000,
+    })
+    const signed = await signEnvelopeEd25519(envelope, keypair.privateKey)
+
+    await new Promise<void>(resolve => {
+      pws.onVerifyFail(() => resolve())
+      ws.receive(JSON.stringify(signed))
+    })
+
+    expect(errors).toHaveLength(1)
+    expect(errors[0].message).toContain('unknown sender')
+  })
+
+  it('malformed JSON calls onVerifyFail', async () => {
+    const keypair = await generateEd25519KeypairBase64Url()
+    const ws = new MockWebSocket()
+    const registry = createStaticKeyRegistry({})
+
+    const pws = wrapWebSocket(ws, {
+      privateKey: keypair.privateKey,
+      sender: 'agent-A',
+      keyRegistry: registry,
+    })
+
+    const errors: Error[] = []
+    pws.onVerifyFail((err) => errors.push(err))
+
+    await new Promise<void>(resolve => {
+      pws.onVerifyFail(() => resolve())
+      ws.receive('this is not valid JSON {{{')
+    })
+
+    expect(errors).toHaveLength(1)
+    expect(errors[0].message).toContain('malformed frame')
+  })
+
+  it('seq increments on each send', async () => {
+    const keypair = await generateEd25519KeypairBase64Url()
+    const ws = new MockWebSocket()
+    const registry = createStaticKeyRegistry({ 'agent-A': keypair.publicKey })
+
+    const pws = wrapWebSocket(ws, {
+      privateKey: keypair.privateKey,
+      sender: 'agent-A',
+      keyRegistry: registry,
+    })
+
+    expect(pws.seq).toBe(0)
+
+    await pws.send('first')
+    expect(pws.seq).toBe(1)
+
+    await pws.send('second')
+    expect(pws.seq).toBe(2)
+
+    await pws.send('third')
+    expect(pws.seq).toBe(3)
+
+    // Verify correlationId carries the seq number
+    const frame1 = JSON.parse(ws.sent[0]) as ProtocolEnvelope
+    const frame2 = JSON.parse(ws.sent[1]) as ProtocolEnvelope
+    const frame3 = JSON.parse(ws.sent[2]) as ProtocolEnvelope
+    expect(frame1.body.correlationId).toBe('1')
+    expect(frame2.body.correlationId).toBe('2')
+    expect(frame3.body.correlationId).toBe('3')
+  })
+})

package/src/wsBinding.ts

@@ -0,0 +1,200 @@
+import {
+  signEnvelopeEd25519, verifyEnvelopeEd25519,
+  createEnvelope, validateEnvelope,
+  generateEd25519KeypairBase64Url, type ProtocolEnvelope
+} from './protocol'
+import type { KeyRegistry } from './keyRegistry'
+import {
+  SignedStreamWriter,
+  verifyStream,
+  decodeStreamChunk,
+  encodeStreamChunk,
+  type StreamSignerOpts,
+  type StreamVerifierOpts,
+  type StreamVerifyResult,
+  type StreamChunk,
+} from './stream'
+
+export { type KeyRegistry, generateEd25519KeypairBase64Url }
+export type { StreamSignerOpts, StreamVerifierOpts, StreamVerifyResult, StreamChunk }
+
+// Minimal WebSocket interface (works with browser WebSocket, ws library, etc.)
+export interface WebSocketLike {
+  send(data: string): void
+  addEventListener(event: 'message', handler: (e: { data: string | Buffer }) => void): void
+  addEventListener(event: 'close', handler: () => void): void
+  removeEventListener(event: string, handler: (...args: unknown[]) => void): void
+  readyState?: number
+}
+
+export interface WsBindingOptions {
+  privateKey: string
+  sender: string
+  recipient?: string
+  keyRegistry: KeyRegistry   // to look up peer public keys by sender ID
+  ttlMs?: number             // per-frame TTL, default 30_000
+  onVerifyFail?: (err: Error, rawData: string) => void
+}
+
+export interface ProtectedWebSocket {
+  // Send a payload — automatically signs it
+  send(payload: unknown): Promise<void>
+  // Register handler for verified incoming messages
+  onMessage(handler: (payload: unknown, envelope: ProtocolEnvelope) => void): void
+  // Register handler for verify failures (optional)
+  onVerifyFail(handler: (err: Error, rawData: string) => void): void
+  // Sequence number of last sent message
+  readonly seq: number
+}
+
+export function wrapWebSocket(ws: WebSocketLike, opts: WsBindingOptions): ProtectedWebSocket {
+  let seq = 0
+  const messageHandlers: Array<(payload: unknown, envelope: ProtocolEnvelope) => void> = []
+  const failHandlers: Array<(err: Error, rawData: string) => void> = []
+
+  function fireVerifyFail(err: Error, raw: string) {
+    opts.onVerifyFail?.(err, raw)
+    for (const h of failHandlers) h(err, raw)
+  }
+
+  // Listen for incoming frames
+  const messageListener = async (e: { data: string | Buffer }) => {
+    const raw = typeof e.data === 'string' ? e.data : e.data.toString('utf8')
+    let envelope: ProtocolEnvelope
+    try { envelope = JSON.parse(raw) as ProtocolEnvelope }
+    catch (err) { fireVerifyFail(new Error('malformed frame'), raw); return }
+
+    const sender = envelope?.header?.sender
+    if (!sender) { fireVerifyFail(new Error('missing sender'), raw); return }
+
+    const publicKey = await opts.keyRegistry.getPublicKey(sender)
+    if (!publicKey) { fireVerifyFail(new Error(`unknown sender: ${sender}`), raw); return }
+
+    const valid = await verifyEnvelopeEd25519(envelope, publicKey).catch(() => false)
+    if (!valid) { fireVerifyFail(new Error('invalid signature'), raw); return }
+
+    const diags = validateEnvelope(envelope)
+    if (diags.some(d => d.level === 'error')) {
+      fireVerifyFail(new Error(`envelope invalid: ${diags.map(d => d.message).join('; ')}`), raw)
+      return
+    }
+
+    let payload: unknown = envelope.body.content
+    try { payload = JSON.parse(envelope.body.content) } catch { /* keep as string */ }
+    for (const h of messageHandlers) h(payload, envelope)
+  }
+
+  ws.addEventListener('message', messageListener as any)
+  ws.addEventListener('close', () => {
+    ws.removeEventListener('message', messageListener as any)
+  })
+
+  return {
+    get seq() { return seq },
+    async send(payload: unknown): Promise<void> {
+      const content = typeof payload === 'string' ? payload : JSON.stringify(payload)
+      const envelope = createEnvelope({
+        sender: opts.sender,
+        recipient: opts.recipient,
+        ttlMs: opts.ttlMs ?? 30_000,
+        intent: 'TASK',
+        content,
+      })
+      // embed sequence number in correlationId to help downstream ordering
+      ;(envelope.body as any).correlationId = String(++seq)
+      const signed = await signEnvelopeEd25519(envelope, opts.privateKey)
+      ws.send(JSON.stringify(signed))
+    },
+    onMessage(handler) { messageHandlers.push(handler) },
+    onVerifyFail(handler) { failHandlers.push(handler) },
+  }
+}
+
+// ─────────────────── Stream signing over WebSocket ────────────────────────────
+
+/**
+ * createSignedWebSocketStream
+ *
+ * Attaches a SignedStreamWriter to a WebSocket:
+ *   - Each incoming WebSocket message is signed as a stream chunk and sent back.
+ *   - On connection close, the final signed frame is sent.
+ *
+ * Returns the underlying SignedStreamWriter so callers can also call writeChunk
+ * directly (e.g. when driving the stream from application code rather than
+ * forwarding received messages).
+ */
+export function createSignedWebSocketStream(
+  ws: WebSocketLike,
+  opts: StreamSignerOpts,
+): SignedStreamWriter {
+  const writer = new SignedStreamWriter(opts)
+
+  const messageListener = async (e: { data: string | Buffer }) => {
+    const data = typeof e.data === 'string' ? e.data : e.data.toString('utf8')
+    const chunk = await writer.writeChunk(data)
+    ws.send(encodeStreamChunk(chunk))
+  }
+
+  const closeListener = async () => {
+    ws.removeEventListener('message', messageListener as any)
+    ws.removeEventListener('close', closeListener as any)
+    const finalChunk = await writer.finalize()
+    ws.send(encodeStreamChunk(finalChunk))
+  }
+
+  ws.addEventListener('message', messageListener as any)
+  ws.addEventListener('close', closeListener as any)
+
+  return writer
+}
+
+/**
+ * receiveSignedWebSocketStream
+ *
+ * Listens for StreamChunk JSON frames on a WebSocket, accumulates them, and
+ * when the final frame (f=true) arrives calls verifyStream over the complete
+ * set of collected chunks.
+ *
+ * Resolves with StreamVerifyResult when the final frame is received.
+ * Rejects if a frame cannot be decoded.
+ */
+export function receiveSignedWebSocketStream(
+  ws: WebSocketLike,
+  opts: StreamVerifierOpts,
+): Promise<StreamVerifyResult> {
+  return new Promise<StreamVerifyResult>((resolve, reject) => {
+    const collected: StreamChunk[] = []
+
+    const messageListener = async (e: { data: string | Buffer }) => {
+      const raw = typeof e.data === 'string' ? e.data : e.data.toString('utf8')
+      let chunk: StreamChunk
+      try {
+        chunk = decodeStreamChunk(raw)
+      } catch (err) {
+        cleanup()
+        reject(err)
+        return
+      }
+      collected.push(chunk)
+      if (chunk.f) {
+        cleanup()
+        const result = await verifyStream(collected, opts)
+        resolve(result)
+      }
+    }
+
+    const closeListener = () => {
+      // Connection closed before receiving final frame
+      cleanup()
+      resolve({ ok: false, reason: 'connection closed before final frame' })
+    }
+
+    function cleanup() {
+      ws.removeEventListener('message', messageListener as any)
+      ws.removeEventListener('close', closeListener as any)
+    }
+
+    ws.addEventListener('message', messageListener as any)
+    ws.addEventListener('close', closeListener as any)
+  })
+}

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "lib": ["ES2023", "DOM"],
+    "types": ["node"],
+    "strict": true,
+    "skipLibCheck": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "verbatimModuleSyntax": false
+  },
+  "include": ["src/**/*.ts", "scripts/**/*.ts"]
+}

package/tsconfig.lib.json

@@ -0,0 +1,23 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "declaration": true,
+    "emitDeclarationOnly": true,
+    "declarationMap": false,
+    "sourceMap": false,
+    "outDir": "./dist/protocol",
+    "rootDir": "./src",
+    "stripInternal": true,
+    "strict": true,
+    "types": ["node"],
+    "skipLibCheck": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedSideEffectImports": true
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["src/**/*.test.ts", "src/**/*.bench.ts"]
+}

package/vite.lib.config.ts

@@ -0,0 +1,16 @@
+import { defineConfig } from 'vite'
+
+export default defineConfig({
+  build: {
+    lib: {
+      entry: 'src/index.ts',
+      formats: ['es'],
+      fileName: () => 'index.js',
+    },
+    outDir: 'dist/protocol',
+    emptyOutDir: false,
+    rollupOptions: {
+      external: [],
+    },
+  },
+})

package/vitest.config.ts

@@ -0,0 +1,11 @@
+import { defineConfig } from 'vitest/config'
+
+export default defineConfig({
+  test: {
+    exclude: [
+      'sdk/pq/dist/**',
+      'sdk/threshold/dist/**',
+      '**/node_modules/**',
+    ],
+  },
+})

package/agentAdapter.d.ts

@@ -1,26 +0,0 @@
-import { type AgentReceiveResult, type AgentSessionConfig } from './protocolAgent';
-import { type IntentKind, type ProtocolEnvelope } from './protocol';
-import { type WireEnvelope, type WireFormat } from './protocolTransport';
-export interface AipAdapterConfig extends AgentSessionConfig {
-    wireFormat?: WireFormat;
-}
-export declare class AipAgentAdapter {
-    private readonly session;
-    private readonly wireFormat;
-    constructor(config: AipAdapterConfig);
-    toRaw(envelope: ProtocolEnvelope): WireEnvelope;
-    createRawIntent(input: {
-        recipient?: string;
-        intent: IntentKind;
-        content: string;
-        capability?: string;
-        correlationId?: string;
-        ttlMs?: number;
-        messageId?: string;
-        nonce?: string;
-        nowMs?: number;
-    }): Promise<WireEnvelope>;
-    receiveRaw(raw: WireEnvelope, nowMs?: number): Promise<AgentReceiveResult>;
-    handleRaw(raw: WireEnvelope, emitResponseRaw: (rawResponse: WireEnvelope, responseEnvelope: ProtocolEnvelope) => void | Promise<void>, nowMs?: number): Promise<AgentReceiveResult>;
-}
-export declare function createAipAgentAdapter(config: AipAdapterConfig): AipAgentAdapter;

package/conformanceVectors.d.ts

@@ -1,20 +0,0 @@
-import type { ProtocolEnvelope } from './protocol';
-export interface ConformanceVector {
-    id: string;
-    secret: string;
-    keyId: string;
-    envelope: Omit<ProtocolEnvelope, 'signature'>;
-    canonical: string;
-    signature: string;
-}
-export interface Ed25519ConformanceVector {
-    id: string;
-    keyId: string;
-    publicKey: string;
-    privateKey: string;
-    envelope: Omit<ProtocolEnvelope, 'signature'>;
-    canonical: string;
-    signature: string;
-}
-export declare const AIP_V01_CONFORMANCE_VECTORS: ConformanceVector[];
-export declare const AIP_V01_ED25519_CONFORMANCE_VECTORS: Ed25519ConformanceVector[];