ethagent 0.2.0 → 1.0.0

package/src/cli/preview.tsx

@@ -0,0 +1,19 @@
+import React from 'react'
+import { Box, render } from 'ink'
+import { BrandSplash } from '../ui/BrandSplash.js'
+
+/**
+ * `ethagent preview` — renders the brand splash with only the tagline
+ * in the top border, no technical details at the bottom, and exits.
+ */
+export async function runPreviewCommand(): Promise<number> {
+  const instance = render(
+    <Box flexDirection="column" marginY={1}>
+      <BrandSplash />
+    </Box>,
+  )
+  // Give Ink one tick to paint, then unmount cleanly.
+  await new Promise<void>(resolve => setTimeout(resolve, 50))
+  instance.unmount()
+  return 0
+}

package/src/cli/reset.ts

@@ -0,0 +1,106 @@
+import { createInterface } from 'node:readline/promises'
+import { stdin as processStdin, stdout as processStdout, stderr as processStderr } from 'node:process'
+import React from 'react'
+import { render } from 'ink'
+import {
+  createFactoryResetPlan,
+  formatFactoryResetPlan,
+  runFactoryReset,
+  type FactoryResetPlan,
+} from '../storage/factoryReset.js'
+import { AppInputProvider } from '../app/input/AppInputProvider.js'
+import { ResetConfirmView } from './ResetConfirmView.js'
+
+export type ResetCommandIO = {
+  write?: (text: string) => void
+  writeError?: (text: string) => void
+  readConfirmation?: () => Promise<string>
+  clearSecrets?: boolean
+  input?: NodeJS.ReadableStream
+  output?: NodeJS.WritableStream
+}
+
+export async function runResetCommand(args: string[] = [], io: ResetCommandIO = {}): Promise<number> {
+  const write = io.write ?? (text => { processStdout.write(text) })
+  const writeError = io.writeError ?? (text => { processStderr.write(text) })
+  const yes = args.includes('--yes') || args.includes('-y')
+  const unknown = args.filter(arg => arg !== '--yes' && arg !== '-y')
+  if (unknown.length > 0) {
+    writeError(`unknown reset option: ${unknown[0]}\nusage: ethagent reset [--yes]\n`)
+    return 2
+  }
+
+  const plan = await createFactoryResetPlan()
+
+  if (!yes) {
+    const confirmed = io.readConfirmation
+      ? await readTextConfirmation(plan, io)
+      : await readInkConfirmation(plan, io)
+    if (!confirmed) {
+      write('factory reset cancelled.\n')
+      return 1
+    }
+  } else {
+    write(`${formatFactoryResetPlan(plan)}\n`)
+  }
+
+  const result = await runFactoryReset({ clearSecrets: io.clearSecrets })
+  write([
+    'factory reset complete.',
+    `deleted ${result.deletedPaths.length} local path${result.deletedPaths.length === 1 ? '' : 's'}.`,
+    `cleared ${result.clearedSecretAccounts.length} known secret account${result.clearedSecretAccounts.length === 1 ? '' : 's'}.`,
+    result.preservedPaths.length > 0
+      ? `preserved local LLM assets: ${result.preservedPaths.length} path${result.preservedPaths.length === 1 ? '' : 's'}.`
+      : 'no local model assets were present.',
+    '',
+  ].join('\n'))
+  return 0
+}
+
+async function readTextConfirmation(plan: FactoryResetPlan, io: ResetCommandIO): Promise<boolean> {
+  ;(io.write ?? (text => { processStdout.write(text) }))(`${formatFactoryResetPlan(plan)}\n`)
+  const answer = await readConfirmation(io)
+  return answer.trim().toLowerCase() === 'confirm'
+}
+
+async function readInkConfirmation(plan: FactoryResetPlan, io: ResetCommandIO): Promise<boolean> {
+  let confirmed = false
+  const instance = render(
+    React.createElement(
+      AppInputProvider,
+      null,
+      React.createElement(ResetConfirmView, {
+        plan,
+        onDone: (value: boolean) => { confirmed = value },
+      }),
+    ),
+    {
+      exitOnCtrlC: false,
+      stdin: (io.input ?? processStdin) as typeof processStdin,
+      stdout: (io.output ?? processStdout) as typeof processStdout,
+    },
+  )
+  try {
+    await instance.waitUntilExit()
+  } catch {
+    return false
+  }
+  return confirmed
+}
+
+async function readConfirmation(io: ResetCommandIO): Promise<string> {
+  if (io.readConfirmation) {
+    ;(io.write ?? (text => { processStdout.write(text) }))('type confirm to wipe local ethagent data: ')
+    return io.readConfirmation()
+  }
+
+  const rl = createInterface({
+    input: io.input ?? processStdin,
+    output: io.output ?? processStdout,
+  })
+  try {
+    return await rl.question('type confirm to wipe local ethagent data: ')
+  } finally {
+    rl.close()
+  }
+}

package/src/identity/continuity/editor.ts

@@ -0,0 +1,149 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import { spawn } from 'node:child_process'
+
+export type EditorOpenResult =
+  | { ok: true; method: string; waited: boolean }
+  | { ok: false; error: string }
+
+export type EditorCommand = {
+  cmd: string
+  args: string[]
+  method: string
+  waited: boolean
+  shell?: boolean
+}
+
+export type EditorResolutionOptions = {
+  platform?: NodeJS.Platform
+  commandExists?: (command: string) => string | null
+}
+
+const IDE_CANDIDATES = ['code', 'cursor', 'windsurf'] as const
+
+export function openFileInEditor(file: string, env: NodeJS.ProcessEnv = process.env): Promise<EditorOpenResult> {
+  const command = resolveEditorCommand(file, env)
+  if (command) return openEditorCommand(command)
+  return openDefaultEditor(file)
+}
+
+export function resolveEditorCommand(
+  file: string,
+  env: NodeJS.ProcessEnv = process.env,
+  options: EditorResolutionOptions = {},
+): EditorCommand | null {
+  const platform = options.platform ?? process.platform
+  const commandExists = options.commandExists ?? (command => findExecutable(command, env, platform))
+
+  const ethagentEditor = env.ETHAGENT_EDITOR?.trim()
+  if (ethagentEditor) return configuredCommand(ethagentEditor, file, true, platform)
+
+  for (const candidate of IDE_CANDIDATES) {
+    const executable = commandExists(candidate)
+    if (executable) {
+      return {
+        cmd: executable,
+        args: [file],
+        method: candidate,
+        waited: false,
+        shell: platform === 'win32' && /\.(?:cmd|bat)$/i.test(executable),
+      }
+    }
+  }
+
+  const configured = env.VISUAL?.trim() || env.EDITOR?.trim()
+  if (configured) return configuredCommand(configured, file, true, platform)
+
+  return defaultEditorCommand(file, platform)
+}
+
+function configuredCommand(commandLine: string, file: string, waited: boolean, platform: NodeJS.Platform): EditorCommand | null {
+  const [cmd, ...args] = splitCommand(commandLine)
+  if (!cmd) return null
+  return {
+    cmd,
+    args: [...args, file],
+    method: path.basename(cmd),
+    waited,
+    shell: platform === 'win32' && /\.(?:cmd|bat)$/i.test(cmd),
+  }
+}
+
+function openEditorCommand(command: EditorCommand): Promise<EditorOpenResult> {
+  return new Promise(resolve => {
+    let child
+    try {
+      child = spawn(command.cmd, command.args, command.waited
+        ? { stdio: 'inherit', shell: command.shell }
+        : { detached: true, stdio: 'ignore', shell: command.shell })
+    } catch (err: unknown) {
+      resolve({ ok: false, error: (err as Error).message })
+      return
+    }
+    child.on('error', err => resolve({ ok: false, error: err.message }))
+    if (!command.waited) {
+      child.unref()
+      resolve({ ok: true, method: command.method, waited: false })
+      return
+    }
+    child.on('close', code => {
+      if (code === 0) resolve({ ok: true, method: command.method, waited: true })
+      else resolve({ ok: false, error: `${command.method} exited ${code}` })
+    })
+  })
+}
+
+function openDefaultEditor(file: string): Promise<EditorOpenResult> {
+  const command = defaultEditorCommand(file)
+  if (!command) return Promise.resolve({ ok: false, error: 'no default editor command for this platform' })
+  return openEditorCommand(command)
+}
+
+function defaultEditorCommand(file: string, platform: NodeJS.Platform = process.platform): EditorCommand | null {
+  if (platform === 'win32') return { cmd: 'cmd', args: ['/c', 'start', '', file], method: 'cmd', waited: false }
+  if (platform === 'darwin') return { cmd: 'open', args: [file], method: 'open', waited: false }
+  return { cmd: 'xdg-open', args: [file], method: 'xdg-open', waited: false }
+}
+
+function splitCommand(commandLine: string): string[] {
+  return commandLine.match(/"[^"]+"|'[^']+'|\S+/g)?.map(part => {
+    if ((part.startsWith('"') && part.endsWith('"')) || (part.startsWith("'") && part.endsWith("'"))) {
+      return part.slice(1, -1)
+    }
+    return part
+  }) ?? []
+}
+
+function findExecutable(command: string, env: NodeJS.ProcessEnv, platform: NodeJS.Platform): string | null {
+  const hasPathSeparator = command.includes('/') || command.includes('\\')
+  if (hasPathSeparator || path.isAbsolute(command)) {
+    return canAccessExecutable(command) ? command : null
+  }
+
+  const pathValue = env.PATH ?? ''
+  const pathParts = pathValue.split(path.delimiter).filter(Boolean)
+  const extensions = platform === 'win32'
+    ? (env.PATHEXT ?? '.EXE;.CMD;.BAT;.COM').split(';').filter(Boolean)
+    : ['']
+
+  for (const dir of pathParts) {
+    for (const ext of extensions) {
+      const candidate = path.join(dir, platform === 'win32' && path.extname(command) === '' ? `${command}${ext.toLowerCase()}` : command)
+      if (canAccessExecutable(candidate)) return candidate
+      if (platform === 'win32') {
+        const upperCandidate = path.join(dir, path.extname(command) === '' ? `${command}${ext.toUpperCase()}` : command)
+        if (canAccessExecutable(upperCandidate)) return upperCandidate
+      }
+    }
+  }
+  return null
+}
+
+function canAccessExecutable(file: string): boolean {
+  try {
+    fs.accessSync(file, fs.constants.X_OK)
+    return true
+  } catch {
+    return false
+  }
+}

package/src/identity/continuity/envelope.ts

@@ -0,0 +1,345 @@
+import crypto from 'node:crypto'
+import { ml_kem1024 } from '@noble/post-quantum/ml-kem.js'
+import { recoverAddressFromSignature, toChecksumAddress } from '../crypto/eth.js'
+
+export const CONTINUITY_SNAPSHOT_ENVELOPE_VERSION = 'ethagent-continuity-snapshot-v1'
+
+export type ContinuityFiles = {
+  'SOUL.md': string
+  'MEMORY.md': string
+}
+
+export type ContinuityTranscriptSummary = {
+  sessionId?: string
+  createdAt?: string
+  summary: string
+}
+
+export type ContinuityAgentSnapshot = {
+  chainId?: number
+  identityRegistryAddress?: string
+  agentId?: string
+  agentUri?: string
+  metadataCid?: string
+  name?: string
+  description?: string
+}
+
+export type ContinuitySnapshotPayload = {
+  version: 1
+  ownerAddress: string
+  createdAt: string
+  sequence?: number
+  agent: ContinuityAgentSnapshot
+  files: ContinuityFiles
+  transcript: ContinuityTranscriptSummary[]
+  state: Record<string, unknown>
+}
+
+export type ContinuitySnapshotEnvelope = {
+  version: 1
+  envelopeVersion: typeof CONTINUITY_SNAPSHOT_ENVELOPE_VERSION
+  ownerAddress: string
+  createdAt: string
+  challenge: string
+  crypto: {
+    kem: 'ML-KEM-1024'
+    aead: 'AES-256-GCM'
+    kdf: 'HKDF-SHA256'
+    signature: 'EIP-191'
+  }
+  salt: string
+  kemPublicKey: string
+  kemCiphertext: string
+  nonce: string
+  ciphertext: string
+  tag: string
+}
+
+export type CreateContinuitySnapshotEnvelopeArgs = {
+  ownerAddress: string
+  walletSignature: string
+  payload: Omit<ContinuitySnapshotPayload, 'version' | 'ownerAddress' | 'createdAt'> & {
+    createdAt?: string
+  }
+}
+
+export type RestoreContinuitySnapshotEnvelopeArgs = {
+  envelope: ContinuitySnapshotEnvelope
+  walletSignature: string
+}
+
+export class ContinuitySnapshotOwnerMismatchError extends Error {
+  constructor(
+    readonly snapshotOwner: string,
+    readonly currentOwner: string,
+  ) {
+    super('continuity snapshot is encrypted for another wallet')
+    this.name = 'ContinuitySnapshotOwnerMismatchError'
+  }
+}
+
+export function createContinuitySnapshotChallenge(ownerAddress: string): string {
+  const checksum = toChecksumAddress(ownerAddress)
+  return [
+    'ethagent private continuity',
+    `Owner: ${checksum}`,
+    'Purpose: unlock the encrypted SOUL.md and MEMORY.md snapshot for this device',
+    'Scope: read and restore private agent continuity only',
+    'Safety: this signature does not send a transaction, spend funds, or grant token approval',
+    'Version: 1',
+  ].join('\n')
+}
+
+export function createContinuitySnapshotEnvelope(args: CreateContinuitySnapshotEnvelopeArgs): ContinuitySnapshotEnvelope {
+  const ownerAddress = toChecksumAddress(args.ownerAddress)
+  const challenge = createContinuitySnapshotChallenge(ownerAddress)
+  assertSignatureForAddress(challenge, args.walletSignature, ownerAddress)
+
+  const createdAt = args.payload.createdAt ?? new Date().toISOString()
+  const payload: ContinuitySnapshotPayload = {
+    version: 1,
+    ownerAddress,
+    createdAt,
+    ...(args.payload.sequence !== undefined ? { sequence: args.payload.sequence } : {}),
+    agent: normalizeAgentSnapshot(args.payload.agent),
+    files: normalizeContinuityFiles(args.payload.files),
+    transcript: normalizeTranscript(args.payload.transcript),
+    state: normalizeState(args.payload.state),
+  }
+
+  const salt = crypto.randomBytes(32)
+  const kemSeed = deriveContinuityKemSeed(args.walletSignature, salt, ownerAddress)
+  const kemKeys = ml_kem1024.keygen(kemSeed)
+  const kem = ml_kem1024.encapsulate(kemKeys.publicKey)
+  const key = deriveContinuityAesKey(args.walletSignature, kem.sharedSecret, salt, ownerAddress)
+  const nonce = crypto.randomBytes(12)
+  const cipher = crypto.createCipheriv('aes-256-gcm', key, nonce)
+  cipher.setAAD(continuityAadFor(ownerAddress, createdAt))
+  const plaintext = Buffer.from(JSON.stringify(payload), 'utf8')
+  const encrypted = Buffer.concat([cipher.update(plaintext), cipher.final()])
+  const tag = cipher.getAuthTag()
+
+  return {
+    version: 1,
+    envelopeVersion: CONTINUITY_SNAPSHOT_ENVELOPE_VERSION,
+    ownerAddress,
+    createdAt,
+    challenge,
+    crypto: {
+      kem: 'ML-KEM-1024',
+      aead: 'AES-256-GCM',
+      kdf: 'HKDF-SHA256',
+      signature: 'EIP-191',
+    },
+    salt: toBase64(salt),
+    kemPublicKey: toBase64(kemKeys.publicKey),
+    kemCiphertext: toBase64(kem.cipherText),
+    nonce: toBase64(nonce),
+    ciphertext: toBase64(encrypted),
+    tag: toBase64(tag),
+  }
+}
+
+export function restoreContinuitySnapshotEnvelope(args: RestoreContinuitySnapshotEnvelopeArgs): ContinuitySnapshotPayload {
+  const envelope = normalizeContinuitySnapshotEnvelope(args.envelope)
+  assertSignatureForAddress(envelope.challenge, args.walletSignature, envelope.ownerAddress)
+
+  const salt = fromBase64(envelope.salt)
+  const kemSeed = deriveContinuityKemSeed(args.walletSignature, salt, envelope.ownerAddress)
+  const kemKeys = ml_kem1024.keygen(kemSeed)
+  const expectedPublicKey = toBase64(kemKeys.publicKey)
+  if (expectedPublicKey !== envelope.kemPublicKey) {
+    throw new Error('wallet signature does not match this continuity snapshot')
+  }
+
+  const sharedSecret = ml_kem1024.decapsulate(fromBase64(envelope.kemCiphertext), kemKeys.secretKey)
+  const key = deriveContinuityAesKey(args.walletSignature, sharedSecret, salt, envelope.ownerAddress)
+  const decipher = crypto.createDecipheriv('aes-256-gcm', key, fromBase64(envelope.nonce))
+  decipher.setAAD(continuityAadFor(envelope.ownerAddress, envelope.createdAt))
+  decipher.setAuthTag(fromBase64(envelope.tag))
+
+  let decoded: unknown
+  try {
+    const plaintext = Buffer.concat([
+      decipher.update(fromBase64(envelope.ciphertext)),
+      decipher.final(),
+    ]).toString('utf8')
+    decoded = JSON.parse(plaintext)
+  } catch {
+    throw new Error('could not decrypt continuity snapshot with the supplied wallet signature')
+  }
+
+  const payload = normalizeContinuityPayload(decoded)
+  if (payload.ownerAddress.toLowerCase() !== envelope.ownerAddress.toLowerCase()) {
+    throw new Error('continuity snapshot owner mismatch')
+  }
+  if (payload.createdAt !== envelope.createdAt) {
+    throw new Error('continuity snapshot timestamp mismatch')
+  }
+  return payload
+}
+
+export function assertContinuitySnapshotOwner(envelope: ContinuitySnapshotEnvelope, currentOwner: string): void {
+  const snapshotOwner = toChecksumAddress(envelope.ownerAddress)
+  const owner = toChecksumAddress(currentOwner)
+  if (snapshotOwner.toLowerCase() !== owner.toLowerCase()) {
+    throw new ContinuitySnapshotOwnerMismatchError(snapshotOwner, owner)
+  }
+}
+
+export function serializeContinuitySnapshotEnvelope(envelope: ContinuitySnapshotEnvelope): string {
+  return JSON.stringify(normalizeContinuitySnapshotEnvelope(envelope), null, 2)
+}
+
+export function parseContinuitySnapshotEnvelope(raw: string | Uint8Array): ContinuitySnapshotEnvelope {
+  const text = typeof raw === 'string' ? raw : new TextDecoder().decode(raw)
+  const parsed = JSON.parse(text) as unknown
+  return normalizeContinuitySnapshotEnvelope(parsed)
+}
+
+function normalizeContinuitySnapshotEnvelope(input: unknown): ContinuitySnapshotEnvelope {
+  if (!isContinuitySnapshotEnvelope(input)) throw new Error('invalid continuity snapshot envelope')
+  if (input.envelopeVersion !== CONTINUITY_SNAPSHOT_ENVELOPE_VERSION) {
+    throw new Error('unsupported continuity snapshot envelope version')
+  }
+  if (input.crypto.kem !== 'ML-KEM-1024' || input.crypto.aead !== 'AES-256-GCM') {
+    throw new Error('unsupported continuity snapshot crypto suite')
+  }
+  return {
+    ...input,
+    ownerAddress: toChecksumAddress(input.ownerAddress),
+  }
+}
+
+function isContinuitySnapshotEnvelope(input: unknown): input is ContinuitySnapshotEnvelope {
+  if (!input || typeof input !== 'object') return false
+  const obj = input as Partial<ContinuitySnapshotEnvelope> & { walletSignature?: unknown }
+  return obj.version === 1
+    && obj.envelopeVersion === CONTINUITY_SNAPSHOT_ENVELOPE_VERSION
+    && typeof obj.ownerAddress === 'string'
+    && typeof obj.createdAt === 'string'
+    && typeof obj.challenge === 'string'
+    && obj.walletSignature === undefined
+    && typeof obj.salt === 'string'
+    && typeof obj.kemPublicKey === 'string'
+    && typeof obj.kemCiphertext === 'string'
+    && typeof obj.nonce === 'string'
+    && typeof obj.ciphertext === 'string'
+    && typeof obj.tag === 'string'
+    && !!obj.crypto
+}
+
+function normalizeContinuityPayload(input: unknown): ContinuitySnapshotPayload {
+  if (!input || typeof input !== 'object') throw new Error('continuity snapshot payload is invalid')
+  const obj = input as Partial<ContinuitySnapshotPayload>
+  if (obj.version !== 1) throw new Error('continuity snapshot payload version is invalid')
+  if (typeof obj.ownerAddress !== 'string') throw new Error('continuity snapshot owner is invalid')
+  if (typeof obj.createdAt !== 'string') throw new Error('continuity snapshot timestamp is invalid')
+  return {
+    version: 1,
+    ownerAddress: toChecksumAddress(obj.ownerAddress),
+    createdAt: obj.createdAt,
+    ...(typeof obj.sequence === 'number' && Number.isSafeInteger(obj.sequence) ? { sequence: obj.sequence } : {}),
+    agent: normalizeAgentSnapshot(obj.agent),
+    files: normalizeContinuityFiles(obj.files),
+    transcript: normalizeTranscript(obj.transcript),
+    state: normalizeState(obj.state),
+  }
+}
+
+function normalizeAgentSnapshot(input: unknown): ContinuityAgentSnapshot {
+  if (!input || typeof input !== 'object' || Array.isArray(input)) return {}
+  const obj = input as Record<string, unknown>
+  return {
+    ...(typeof obj.chainId === 'number' && Number.isSafeInteger(obj.chainId) && obj.chainId > 0 ? { chainId: obj.chainId } : {}),
+    ...(typeof obj.identityRegistryAddress === 'string' ? { identityRegistryAddress: obj.identityRegistryAddress } : {}),
+    ...(typeof obj.agentId === 'string' ? { agentId: obj.agentId } : {}),
+    ...(typeof obj.agentUri === 'string' ? { agentUri: obj.agentUri } : {}),
+    ...(typeof obj.metadataCid === 'string' ? { metadataCid: obj.metadataCid } : {}),
+    ...(typeof obj.name === 'string' ? { name: obj.name } : {}),
+    ...(typeof obj.description === 'string' ? { description: obj.description } : {}),
+  }
+}
+
+function normalizeContinuityFiles(input: unknown): ContinuityFiles {
+  if (!input || typeof input !== 'object' || Array.isArray(input)) {
+    throw new Error('continuity snapshot files are invalid')
+  }
+  const obj = input as Partial<ContinuityFiles>
+  if (typeof obj['SOUL.md'] !== 'string') throw new Error('SOUL.md is missing from continuity snapshot')
+  if (typeof obj['MEMORY.md'] !== 'string') throw new Error('MEMORY.md is missing from continuity snapshot')
+  return {
+    'SOUL.md': obj['SOUL.md'],
+    'MEMORY.md': obj['MEMORY.md'],
+  }
+}
+
+function normalizeTranscript(input: unknown): ContinuityTranscriptSummary[] {
+  if (!Array.isArray(input)) return []
+  return input.flatMap(item => {
+    if (!item || typeof item !== 'object' || Array.isArray(item)) return []
+    const obj = item as Partial<ContinuityTranscriptSummary>
+    if (typeof obj.summary !== 'string' || !obj.summary.trim()) return []
+    return [{
+      ...(typeof obj.sessionId === 'string' ? { sessionId: obj.sessionId } : {}),
+      ...(typeof obj.createdAt === 'string' ? { createdAt: obj.createdAt } : {}),
+      summary: obj.summary,
+    }]
+  })
+}
+
+function normalizeState(input: unknown): Record<string, unknown> {
+  if (!input || typeof input !== 'object' || Array.isArray(input)) return {}
+  return input as Record<string, unknown>
+}
+
+function assertSignatureForAddress(challenge: string, signature: string, address: string): void {
+  const recovered = recoverAddressFromSignature(challenge, signature)
+  if (recovered.toLowerCase() !== address.toLowerCase()) {
+    throw new Error('wallet signature does not match continuity snapshot owner')
+  }
+}
+
+function deriveContinuityKemSeed(walletSignature: string, salt: Uint8Array, ownerAddress: string): Uint8Array {
+  return hkdf(
+    Buffer.from(walletSignature, 'utf8'),
+    salt,
+    `ethagent:${CONTINUITY_SNAPSHOT_ENVELOPE_VERSION}:ml-kem1024:${ownerAddress.toLowerCase()}`,
+    64,
+  )
+}
+
+function deriveContinuityAesKey(
+  walletSignature: string,
+  sharedSecret: Uint8Array,
+  salt: Uint8Array,
+  ownerAddress: string,
+): Buffer {
+  return Buffer.from(hkdf(
+    Buffer.concat([
+      Buffer.from(walletSignature, 'utf8'),
+      Buffer.from('\n', 'utf8'),
+      Buffer.from(sharedSecret),
+    ]),
+    salt,
+    `ethagent:${CONTINUITY_SNAPSHOT_ENVELOPE_VERSION}:aes-256-gcm:${ownerAddress.toLowerCase()}`,
+    32,
+  ))
+}
+
+function continuityAadFor(ownerAddress: string, createdAt: string): Buffer {
+  return Buffer.from(`${CONTINUITY_SNAPSHOT_ENVELOPE_VERSION}\n${ownerAddress.toLowerCase()}\n${createdAt}`, 'utf8')
+}
+
+function hkdf(ikm: Uint8Array, salt: Uint8Array, info: string, length: number): Uint8Array {
+  return new Uint8Array(crypto.hkdfSync('sha256', ikm, salt, Buffer.from(info, 'utf8'), length))
+}
+
+function toBase64(bytes: Uint8Array): string {
+  return Buffer.from(bytes).toString('base64')
+}
+
+function fromBase64(value: string): Uint8Array {
+  return new Uint8Array(Buffer.from(value, 'base64'))
+}