lyra-core 0.1.0

package/src/tools/registry.ts

@@ -0,0 +1,152 @@
+import type { ToolCall, ToolDef, ToolResult, ToolSchema } from './types'
+import { zodToJsonSchema } from './zod-schema'
+
+interface EnablementRule {
+  pattern: string
+  regex: RegExp | null
+  enabled: boolean
+}
+
+/**
+ * Symbol-based tool registry. Tools self-register at import time (plugins
+ * contribute by importing their entry module, which triggers the registry
+ * call). Glob-style enable/disable via `config.tools` is applied at `list()`.
+ *
+ * Deferred-tool model (Claude Code-compatible): tools default to alwaysLoad
+ * (eager). A tool with `shouldDefer: true` (and not `alwaysLoad: true`) is
+ * hidden from `schemas()` until `unlock(name)` is called. The brain hydrates
+ * deferred schemas via the `tool.search` meta-tool.
+ */
+export class ToolRegistry {
+  private readonly tools = new Map<string, ToolDef>()
+  private readonly rules: EnablementRule[]
+  private readonly unlocked = new Set<string>()
+
+  constructor(enabled: Record<string, boolean> = {}) {
+    this.rules = Object.entries(enabled).map(([pattern, on]) => ({
+      pattern,
+      regex: pattern.includes('*') ? new RegExp(`^${pattern.replace(/\*/g, '.*')}$`) : null,
+      enabled: on,
+    }))
+  }
+
+  register(def: ToolDef): void {
+    if (this.tools.has(def.name)) {
+      throw new Error(`Tool already registered: ${def.name}`)
+    }
+    this.tools.set(def.name, def as ToolDef<unknown>)
+  }
+
+  find(name: string): ToolDef | undefined {
+    const tool = this.tools.get(name)
+    if (!tool) return undefined
+    if (!this.isEnabled(name)) return undefined
+    return tool
+  }
+
+  /** All registered + enabled tools, regardless of defer state. */
+  list(): ToolDef[] {
+    return [...this.tools.values()].filter(t => this.isEnabled(t.name))
+  }
+
+  /** Tools whose schemas the brain should see this turn. */
+  loadedList(): ToolDef[] {
+    return this.list().filter(t => this.isLoaded(t))
+  }
+
+  /** OpenAI-format schemas for the eager (loaded) set; sent to Sui Compute. */
+  schemas(): ToolSchema[] {
+    return this.loadedList().map(t => ({
+      type: 'function',
+      function: {
+        name: t.name,
+        description: t.description,
+        parameters: t.parametersOverride ?? zodToJsonSchema(t.schema),
+      },
+    }))
+  }
+
+  /**
+   * Mark a deferred tool as loaded so its schema appears in the next
+   * `schemas()` call. Idempotent.
+   */
+  unlock(name: string): boolean {
+    const tool = this.tools.get(name)
+    if (!tool) return false
+    this.unlocked.add(name)
+    return true
+  }
+
+  /** Whether the brain currently sees the tool's schema. */
+  isLoaded(tool: ToolDef): boolean {
+    if (tool.shouldDefer && tool.alwaysLoad !== true) {
+      return this.unlocked.has(tool.name)
+    }
+    return true
+  }
+
+  /**
+   * Search the registry for tools matching either an exact-name select query
+   * (`select:fs.read,fs.write`) or a free-text keyword query that matches
+   * names, descriptions, and searchHints.
+   */
+  search(query: string, maxResults = 5): ToolDef[] {
+    const trimmed = query.trim()
+    if (trimmed.startsWith('select:')) {
+      const names = trimmed
+        .slice('select:'.length)
+        .split(',')
+        .map(s => s.trim())
+        .filter(Boolean)
+      return names
+        .map(n => this.tools.get(n))
+        .filter((t): t is ToolDef => !!t && this.isEnabled(t.name))
+        .slice(0, maxResults)
+    }
+    const required: string[] = []
+    const keywords: string[] = []
+    for (const part of trimmed.toLowerCase().split(/\s+/).filter(Boolean)) {
+      if (part.startsWith('+')) required.push(part.slice(1))
+      else keywords.push(part)
+    }
+    const scored: { tool: ToolDef; score: number }[] = []
+    for (const tool of this.list()) {
+      const haystack = [tool.name, tool.description, tool.searchHint ?? ''].join(' ').toLowerCase()
+      if (!required.every(r => haystack.includes(r))) continue
+      let score = required.length > 0 ? 1 : 0
+      for (const kw of keywords) {
+        if (haystack.includes(kw)) score++
+      }
+      if (score > 0) scored.push({ tool, score })
+    }
+    return scored
+      .sort((a, b) => b.score - a.score)
+      .slice(0, maxResults)
+      .map(c => c.tool)
+  }
+
+  async dispatch(call: ToolCall): Promise<ToolResult> {
+    const tool = this.find(call.name)
+    if (!tool) return { ok: false, error: `Unknown tool: ${call.name}` }
+    const parsed = tool.schema.safeParse(call.args)
+    if (!parsed.success) {
+      return { ok: false, error: `Invalid args: ${parsed.error.message}` }
+    }
+    try {
+      return await tool.handler(parsed.data)
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e)
+      return { ok: false, error: msg }
+    }
+  }
+
+  private isEnabled(name: string): boolean {
+    // Right-most matching rule wins. No explicit rule = enabled by default.
+    let decision: boolean | null = null
+    for (const rule of this.rules) {
+      const matches = rule.regex ? rule.regex.test(name) : rule.pattern === name
+      if (matches) decision = rule.enabled
+    }
+    return decision ?? true
+  }
+}

package/src/tools/types.ts

@@ -0,0 +1,65 @@
+import type { z } from 'zod'
+
+/** OpenAI-compatible JSON Schema for a function parameter spec. */
+export interface JSONSchema {
+  type: 'object'
+  properties: Record<string, unknown>
+  required?: string[]
+  additionalProperties?: boolean
+  description?: string
+}
+
+/** Shape we hand to the brain when asking it to plan with tools. */
+export interface ToolSchema {
+  type: 'function'
+  function: {
+    name: string
+    description: string
+    parameters: JSONSchema
+  }
+}
+
+export interface ToolCall {
+  id: string
+  name: string
+  args: unknown
+}
+
+export interface ToolDef<TArgs = unknown> {
+  name: string
+  description: string
+  /** zod schema the runtime uses to both validate AND build JSONSchema for the brain. */
+  schema: z.ZodType<TArgs>
+  handler: (args: TArgs) => Promise<ToolResult> | ToolResult
+  /**
+   * When set with `shouldDefer`, overrides the deferral so the tool's schema
+   * still ships every turn. Has no effect when `shouldDefer` is false/unset.
+   */
+  alwaysLoad?: boolean
+  /**
+   * Hide this tool's schema by default; the brain only sees it after
+   * `tool.search` matches it (mirrors Claude Code's shouldDefer). Combine with
+   * `alwaysLoad: true` to force eager loading even though the tool is meant
+   * to be searchable.
+   */
+  shouldDefer?: boolean
+  /**
+   * 3-10 word hint used by `tool.search` keyword matching when this tool is
+   * deferred. Should describe domain ("filesystem read text"), not phrasing.
+   */
+  searchHint?: string
+  /**
+   * Optional JSON Schema override for tools whose param shape isn't expressed
+   * as a top-level `z.object({})` (MCP tools, dynamically-discovered remote
+   * tools). When set, `registry.schemas()` and `tool.search` use this verbatim
+   * instead of running `zodToJsonSchema(schema)`. The `schema.safeParse()`
+   * still gates dispatch.
+   */
+  parametersOverride?: JSONSchema
+}
+
+export interface ToolResult {
+  ok: boolean
+  data?: unknown
+  error?: string
+}

package/src/tools/zod-helpers.test.ts

@@ -0,0 +1,63 @@
+import { describe, expect, it } from 'bun:test'
+import { z } from 'zod'
+import { coerceBool, coerceInt } from './zod-helpers'
+import { zodToJsonSchema } from './zod-schema'
+
+describe('coerceBool', () => {
+  it('accepts native booleans', () => {
+    expect(coerceBool.parse(true)).toBe(true)
+    expect(coerceBool.parse(false)).toBe(false)
+  })
+
+  it('coerces "true"/"false" strings (qwen3.6-plus quirk)', () => {
+    expect(coerceBool.parse('true')).toBe(true)
+    expect(coerceBool.parse('True')).toBe(true)
+    expect(coerceBool.parse('false')).toBe(false)
+    expect(coerceBool.parse('False')).toBe(false)
+  })
+
+  it('coerces 0/1 + yes/no', () => {
+    expect(coerceBool.parse(1)).toBe(true)
+    expect(coerceBool.parse(0)).toBe(false)
+    expect(coerceBool.parse('yes')).toBe(true)
+    expect(coerceBool.parse('no')).toBe(false)
+  })
+
+  it('rejects garbage', () => {
+    expect(() => coerceBool.parse('maybe')).toThrow()
+    expect(() => coerceBool.parse({})).toThrow()
+  })
+
+  it('zodToJsonSchema unwraps to type:boolean', () => {
+    const schema = z.object({ flag: coerceBool.optional() })
+    const json = zodToJsonSchema(schema)
+    expect((json.properties.flag as { type: string }).type).toBe('boolean')
+  })
+})
+
+describe('coerceInt', () => {
+  it('accepts native integers', () => {
+    expect(coerceInt.parse(0)).toBe(0)
+    expect(coerceInt.parse(42)).toBe(42)
+    expect(coerceInt.parse(-7)).toBe(-7)
+  })
+
+  it('coerces "400"/"42" strings (qwen3.6-plus numeric quirk)', () => {
+    expect(coerceInt.parse('400')).toBe(400)
+    expect(coerceInt.parse('  42  ')).toBe(42)
+    expect(coerceInt.parse('-7')).toBe(-7)
+  })
+
+  it('rejects floats + garbage strings', () => {
+    expect(() => coerceInt.parse('1.5')).toThrow()
+    expect(() => coerceInt.parse('abc')).toThrow()
+    expect(() => coerceInt.parse('')).toThrow()
+    expect(() => coerceInt.parse({})).toThrow()
+  })
+
+  it('zodToJsonSchema unwraps to type:number', () => {
+    const schema = z.object({ count: coerceInt.optional() })
+    const json = zodToJsonSchema(schema)
+    expect((json.properties.count as { type: string }).type).toBe('number')
+  })
+})

package/src/tools/zod-helpers.ts

@@ -0,0 +1,36 @@
+import { z } from 'zod'
+
+/**
+ * Some Sui Compute providers (qwen3.6-plus among them) serialize tool-call
+ * boolean args as the strings "true"/"false" instead of JSON booleans. This
+ * accepts either form and falls back to actual booleans + 0/1 numbers.
+ */
+export const coerceBool: z.ZodType<boolean> = z.preprocess(v => {
+  if (typeof v === 'boolean') return v
+  if (typeof v === 'number') return v !== 0
+  if (typeof v === 'string') {
+    const lower = v.trim().toLowerCase()
+    if (lower === 'true' || lower === '1' || lower === 'yes') return true
+    if (lower === 'false' || lower === '0' || lower === 'no') return false
+  }
+  return v
+}, z.boolean()) as unknown as z.ZodType<boolean>
+
+/**
+ * Same shape as coerceBool but for integers. qwen3.6-plus and other Sui
+ * Compute providers sometimes serialize numeric tool-call args as strings
+ * ("400" instead of 400). zod's z.number() rejects them with
+ * "Expected number, received string". Wrap any numeric tool arg with
+ * `coerceInt` (or `coerceInt.refine(n => n > 0, 'must be positive')`) so the
+ * validation passes regardless of how the brain stringifies it.
+ */
+export const coerceInt: z.ZodType<number> = z.preprocess(v => {
+  if (typeof v === 'number') return v
+  if (typeof v === 'string') {
+    const trimmed = v.trim()
+    if (trimmed === '') return v
+    const n = Number(trimmed)
+    if (Number.isFinite(n) && Math.trunc(n) === n) return n
+  }
+  return v
+}, z.number().int()) as unknown as z.ZodType<number>

package/src/tools/zod-schema.ts

@@ -0,0 +1,99 @@
+import type { z } from 'zod'
+import type { JSONSchema } from './types'
+
+/**
+ * Convert a zod object schema to the minimal JSON Schema dialect Sui Compute
+ * (and the OpenAI tool-calling format) expects. Handles: string, number,
+ * boolean, enum, optional, array, nested object. Good enough for phase 1-3
+ * MVP tools; revisit when we need deeper schema features.
+ */
+export function zodToJsonSchema(schema: z.ZodType, description?: string): JSONSchema {
+  const shape = unwrapObjectShape(schema)
+  if (!shape) throw new Error('Top-level tool schema must be a z.object({ ... })')
+  return objectShapeToJson(shape, description) as unknown as JSONSchema
+}
+
+type ZodObjectLike = { _def: { typeName: string; shape: () => Record<string, z.ZodType> } }
+
+function unwrapObjectShape(schema: z.ZodType): Record<string, z.ZodType> | null {
+  const s = schema as unknown as ZodObjectLike
+  if (s._def?.typeName === 'ZodObject') return s._def.shape()
+  return null
+}
+
+function unwrapOptional(schema: z.ZodType): { schema: z.ZodType; optional: boolean } {
+  const s = schema as unknown as {
+    _def: { typeName: string; innerType?: z.ZodType; schema?: z.ZodType }
+  }
+  if (s._def?.typeName === 'ZodOptional' || s._def?.typeName === 'ZodDefault') {
+    return { schema: s._def.innerType!, optional: true }
+  }
+  if (s._def?.typeName === 'ZodEffects') {
+    const inner = unwrapOptional(s._def.schema!)
+    return inner
+  }
+  return { schema, optional: false }
+}
+
+function objectShapeToJson(
+  shape: Record<string, z.ZodType>,
+  description?: string,
+): Record<string, unknown> {
+  const properties: Record<string, unknown> = {}
+  const required: string[] = []
+  for (const [key, value] of Object.entries(shape)) {
+    const { schema: prop, optional } = unwrapOptional(value)
+    properties[key] = zodTypeToJson(prop)
+    if (!optional) required.push(key)
+  }
+  return {
+    type: 'object',
+    properties,
+    ...(required.length ? { required } : {}),
+    additionalProperties: false,
+    ...(description ? { description } : {}),
+  }
+}
+
+function zodTypeToJson(schema: z.ZodType): unknown {
+  const s = schema as unknown as {
+    _def: {
+      typeName: string
+      description?: string
+      values?: string[]
+      type?: z.ZodType
+      shape?: () => Record<string, z.ZodType>
+    }
+  }
+  const t = s._def.typeName
+  const description = s._def.description
+
+  switch (t) {
+    case 'ZodString':
+      return { type: 'string', ...(description ? { description } : {}) }
+    case 'ZodNumber':
+      return { type: 'number', ...(description ? { description } : {}) }
+    case 'ZodBoolean':
+      return { type: 'boolean', ...(description ? { description } : {}) }
+    case 'ZodEnum':
+      return {
+        type: 'string',
+        enum: s._def.values,
+        ...(description ? { description } : {}),
+      }
+    case 'ZodArray':
+      return {
+        type: 'array',
+        items: zodTypeToJson(s._def.type!),
+        ...(description ? { description } : {}),
+      }
+    case 'ZodObject':
+      return objectShapeToJson(s._def.shape?.() ?? {}, description)
+    case 'ZodEffects': {
+      const inner = (s._def as unknown as { schema: z.ZodType }).schema
+      return zodTypeToJson(inner)
+    }
+    default:
+      return { description: description ?? 'unspecified' }
+  }
+}

package/src/wallet/drain.test.ts

@@ -0,0 +1,41 @@
+import { describe, expect, test } from 'bun:test'
+import { SWEEP_GAS_RESERVE_MIST, computeSweepAmount } from './drain'
+
+const AGENT = `0x${'1'.repeat(64)}`
+/** 1 SUI in MIST. */
+const sui = (n: number): bigint => BigInt(Math.round(n * 1e9))
+
+describe('computeSweepAmount', () => {
+  test('subtracts default gas reserve from balance when comfortable', () => {
+    const balanceMist = sui(0.1)
+    const r = computeSweepAmount({ balanceMist, agentAddress: AGENT })
+    expect(r.error).toBeUndefined()
+    expect(r.gasReserve).toBe(SWEEP_GAS_RESERVE_MIST)
+    expect(r.value).toBe(balanceMist - SWEEP_GAS_RESERVE_MIST)
+  })
+
+  test('returns error string when balance below reserve', () => {
+    const balanceMist = SWEEP_GAS_RESERVE_MIST
+    const r = computeSweepAmount({ balanceMist, agentAddress: AGENT })
+    expect(r.value).toBe(0n)
+    expect(r.error).toContain('below gas reserve')
+  })
+
+  test('honors gasReserveOverride', () => {
+    const balanceMist = sui(1)
+    const override = sui(0.005)
+    const r = computeSweepAmount({
+      balanceMist,
+      agentAddress: AGENT,
+      gasReserveOverride: override,
+    })
+    expect(r.gasReserve).toBe(override)
+    expect(r.value).toBe(balanceMist - override)
+  })
+
+  test('error wording surfaces the agent address + balance + reserve', () => {
+    const r = computeSweepAmount({ balanceMist: 0n, agentAddress: AGENT })
+    expect(r.error).toContain(AGENT)
+    expect(r.error).toContain('0.000000 SUI')
+  })
+})

package/src/wallet/drain.ts

@@ -0,0 +1,76 @@
+import { Transaction } from '@mysten/sui/transactions'
+import { getSuiBalanceMist, keypairFromSecret, makeSuiClient } from '../chain'
+import type { LyraNetwork } from '../config'
+import { formatSui } from '../format'
+
+/**
+ * Sweep an agent's SUI balance to a recipient address. Reserves a fixed amount
+ * of MIST for the sweep transaction's own gas, so the resulting balance is "as
+ * close to 0 as the gas reserve allows" without underpaying.
+ *
+ * Used by `lyra drain` for fund recovery on a retiring agent.
+ */
+
+export interface DrainAgentResult {
+  digest: string
+  amountSent: bigint
+  gasReserved: bigint
+}
+
+/** Default MIST kept aside to cover the sweep transaction's gas. ~0.01 SUI. */
+export const SWEEP_GAS_RESERVE_MIST = 10_000_000n
+
+/**
+ * Pure helper: given balance + optional reserve override, return the value to
+ * send, the gas reserve, and an error message if the balance can't cover the
+ * sweep. Lifted out so it can be unit-tested without a live RPC.
+ */
+export function computeSweepAmount(opts: {
+  balanceMist: bigint
+  agentAddress: string
+  gasReserveOverride?: bigint
+}): { value: bigint; gasReserve: bigint; error?: string } {
+  const gasReserve = opts.gasReserveOverride ?? SWEEP_GAS_RESERVE_MIST
+  if (opts.balanceMist <= gasReserve) {
+    return {
+      value: 0n,
+      gasReserve,
+      error: `agent ${opts.agentAddress} has ${formatSui(opts.balanceMist)} SUI; below gas reserve ${formatSui(gasReserve)} SUI`,
+    }
+  }
+  return { value: opts.balanceMist - gasReserve, gasReserve }
+}
+
+export async function drainAgentEOA(opts: {
+  network: LyraNetwork
+  secret: string
+  to: string
+  /** Override the gas reserve (in MIST). Default = SWEEP_GAS_RESERVE_MIST. */
+  gasReserveMist?: bigint
+}): Promise<DrainAgentResult> {
+  const client = makeSuiClient(opts.network)
+  const keypair = keypairFromSecret(opts.secret)
+  const address = keypair.getPublicKey().toSuiAddress()
+
+  const balance = await getSuiBalanceMist(client, address)
+  const sweep = computeSweepAmount({
+    balanceMist: balance,
+    agentAddress: address,
+    gasReserveOverride: opts.gasReserveMist,
+  })
+  if (sweep.error) throw new Error(sweep.error)
+
+  const tx = new Transaction()
+  tx.setGasBudget(sweep.gasReserve)
+  const [coin] = tx.splitCoins(tx.gas, [tx.pure.u64(sweep.value)])
+  tx.transferObjects([coin], tx.pure.address(opts.to))
+
+  const result = await client.signAndExecuteTransaction({
+    signer: keypair,
+    transaction: tx,
+    options: { showEffects: true },
+  })
+  await client.waitForTransaction({ digest: result.digest })
+
+  return { digest: result.digest, amountSent: sweep.value, gasReserved: sweep.gasReserve }
+}

package/src/wallet/eoa.ts

@@ -0,0 +1,61 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises'
+import { dirname } from 'node:path'
+import { Ed25519Keypair } from '@mysten/sui/keypairs/ed25519'
+import { type EncryptedKeystore, decryptKey, encryptKey } from './keystore'
+
+/**
+ * Sui agent wallet material. Callers reconstruct the keypair at point of use
+ * via `Ed25519Keypair.fromSecretKey(secret)` (or `keypairFromSecret`).
+ */
+export interface AgentWalletMaterial {
+  /** Bech32 Sui secret key (`suiprivkey1...`). */
+  secret: string
+  /** Sui address derived from the key (`0x`-prefixed). */
+  address: string
+}
+
+/**
+ * Generate a fresh Ed25519 agent keypair. Returns the bech32 secret
+ * (`suiprivkey1...`) and the derived Sui address.
+ */
+export function generateAgentKeypair(): { address: string; secret: string } {
+  const kp = Ed25519Keypair.generate()
+  return {
+    address: kp.getPublicKey().toSuiAddress(),
+    secret: kp.getSecretKey(),
+  }
+}
+
+/** Back-compat alias used across Lyra: an agent "wallet" is its keypair. */
+export function generateAgentWallet(): AgentWalletMaterial {
+  return generateAgentKeypair()
+}
+
+export async function saveKeystore(
+  path: string,
+  secret: string,
+  passphrase: string,
+): Promise<void> {
+  // Persist the raw secret string bytes; chain-agnostic AES-GCM keystore.
+  const secretBytes = new TextEncoder().encode(secret)
+  const encrypted = encryptKey(secretBytes, passphrase)
+  await mkdir(dirname(path), { recursive: true })
+  await writeFile(path, JSON.stringify(encrypted, null, 2), 'utf8')
+}
+
+export async function loadKeystore(path: string, passphrase: string): Promise<AgentWalletMaterial> {
+  let raw: string
+  try {
+    raw = await readFile(path, 'utf8')
+  } catch (e) {
+    if ((e as NodeJS.ErrnoException).code === 'ENOENT') {
+      throw new Error(`Keystore not found at ${path}`)
+    }
+    throw e
+  }
+  const encrypted = JSON.parse(raw) as EncryptedKeystore
+  const secretBytes = decryptKey(encrypted, passphrase)
+  const secret = new TextDecoder().decode(secretBytes)
+  const kp = Ed25519Keypair.fromSecretKey(secret)
+  return { secret, address: kp.getPublicKey().toSuiAddress() }
+}

package/src/wallet/index.ts

@@ -0,0 +1,14 @@
+export { encryptKey, decryptKey, type EncryptedKeystore } from './keystore'
+export {
+  generateAgentKeypair,
+  generateAgentWallet,
+  saveKeystore,
+  loadKeystore,
+  type AgentWalletMaterial,
+} from './eoa'
+export {
+  drainAgentEOA,
+  computeSweepAmount,
+  SWEEP_GAS_RESERVE_MIST,
+  type DrainAgentResult,
+} from './drain'

package/src/wallet/keystore.test.ts

@@ -0,0 +1,17 @@
+import { expect, test } from 'bun:test'
+import { randomBytes } from 'node:crypto'
+import { decryptKey, encryptKey } from './keystore'
+
+test('encrypt + decrypt round-trip', () => {
+  const pk = new Uint8Array(randomBytes(32))
+  const encrypted = encryptKey(pk, 'test-passphrase')
+  expect(encrypted.version).toBe(1)
+  const decrypted = decryptKey(encrypted, 'test-passphrase')
+  expect(Buffer.from(decrypted).toString('hex')).toBe(Buffer.from(pk).toString('hex'))
+})
+
+test('wrong passphrase fails', () => {
+  const pk = new Uint8Array(32).fill(0xab)
+  const encrypted = encryptKey(pk, 'right')
+  expect(() => decryptKey(encrypted, 'wrong')).toThrow()
+})

package/src/wallet/keystore.ts

@@ -0,0 +1,50 @@
+import { createCipheriv, createDecipheriv, randomBytes, scryptSync } from 'node:crypto'
+
+/**
+ * Simple AES-256-GCM keystore for the agent EOA privkey. Passphrase-derived
+ * key via scrypt. Format packs salt || iv || tag || ciphertext in base64.
+ */
+export interface EncryptedKeystore {
+  version: 1
+  /** Base64-encoded `salt(16) || iv(12) || tag(16) || ciphertext`. */
+  blob: string
+}
+
+const KEY_LEN = 32
+const SCRYPT_N = 2 ** 15
+const SCRYPT_R = 8
+const SCRYPT_P = 1
+const SCRYPT_MAXMEM = 64 * 1024 * 1024
+
+function derive(passphrase: string, salt: Buffer): Buffer {
+  return scryptSync(passphrase, salt, KEY_LEN, {
+    N: SCRYPT_N,
+    r: SCRYPT_R,
+    p: SCRYPT_P,
+    maxmem: SCRYPT_MAXMEM,
+  })
+}
+
+export function encryptKey(privkey: Uint8Array, passphrase: string): EncryptedKeystore {
+  const salt = randomBytes(16)
+  const iv = randomBytes(12)
+  const key = derive(passphrase, salt)
+  const cipher = createCipheriv('aes-256-gcm', key, iv)
+  const ct = Buffer.concat([cipher.update(Buffer.from(privkey)), cipher.final()])
+  const tag = cipher.getAuthTag()
+  const blob = Buffer.concat([salt, iv, tag, ct]).toString('base64')
+  return { version: 1, blob }
+}
+
+export function decryptKey(keystore: EncryptedKeystore, passphrase: string): Uint8Array {
+  if (keystore.version !== 1) throw new Error(`Unsupported keystore version: ${keystore.version}`)
+  const buf = Buffer.from(keystore.blob, 'base64')
+  const salt = buf.subarray(0, 16)
+  const iv = buf.subarray(16, 28)
+  const tag = buf.subarray(28, 44)
+  const ct = buf.subarray(44)
+  const key = derive(passphrase, salt)
+  const decipher = createDecipheriv('aes-256-gcm', key, iv)
+  decipher.setAuthTag(tag)
+  return new Uint8Array(Buffer.concat([decipher.update(ct), decipher.final()]))
+}