@toon-protocol/core 1.1.1

package/dist/index.d.ts

@@ -0,0 +1,2853 @@
+import { T as ToonError } from './index-DSgMeweu.js';
+export { I as InvalidEventError, P as PeerDiscoveryError, a as ToonDecodeError, b as ToonEncodeError, c as ToonRoutingMeta, d as decodeEventFromToon, e as encodeEventToToon, f as encodeEventToToonString, s as shallowParseToon } from './index-DSgMeweu.js';
+import { NostrEvent } from 'nostr-tools/pure';
+import { SimplePool } from 'nostr-tools/pool';
+import { TurboAuthenticatedClient } from '@ardrive/turbo-sdk';
+
+/**
+ * Nostr event kind constants for ILP-related events.
+ *
+ * These follow the NIP convention for replaceable (10000-19999) event kinds.
+ */
+/**
+ * ILP Peer Info (kind 10032)
+ * Replaceable event containing connector's ILP address, BTP endpoint, and settlement info.
+ */
+declare const ILP_PEER_INFO_KIND = 10032;
+/**
+ * Service Discovery (kind 10035)
+ * Replaceable event advertising a node's capabilities, pricing, and endpoints.
+ * Published to the local relay and optionally to peers so that clients and
+ * agents can programmatically discover available services.
+ * NIP-16 replaceable: relays store only the latest event per pubkey + kind.
+ */
+declare const SERVICE_DISCOVERY_KIND = 10035;
+/**
+ * Seed Relay List (kind 10036)
+ * Replaceable event containing a list of relay nodes that serve as bootstrap
+ * entry points for new network participants. Published to public Nostr relays.
+ * NIP-16 replaceable: relays store only the latest event per pubkey + kind.
+ */
+declare const SEED_RELAY_LIST_KIND = 10036;
+/**
+ * TEE Attestation (kind 10033)
+ * NIP-16 replaceable event containing TEE attestation data: PCR values,
+ * enclave image hash, and attestation documents from the TEE platform.
+ * Published by nodes running in a Trusted Execution Environment (e.g.,
+ * Marlin Oyster CVM / AWS Nitro Enclaves). Relays store only the latest
+ * event per pubkey + kind. No `d` tag needed -- NIP-16 replaces by
+ * pubkey + kind alone (unlike NIP-33 parameterized replaceable events).
+ */
+declare const TEE_ATTESTATION_KIND = 10033;
+/**
+ * Base kind for NIP-90 DVM job requests (kind range 5000-5999).
+ * Job requests are regular (non-replaceable) events. Each specific DVM task
+ * type is assigned a unique kind within this range (e.g., 5100 for text
+ * generation). Providers listen for requests in their supported kind range.
+ */
+declare const JOB_REQUEST_KIND_BASE = 5000;
+/**
+ * Base kind for NIP-90 DVM job results (kind range 6000-6999).
+ * Result kind = request kind + 1000 (e.g., Kind 5100 request -> Kind 6100
+ * result). Result events reference the original request via an `e` tag and
+ * include the compute cost in an `amount` tag.
+ */
+declare const JOB_RESULT_KIND_BASE = 6000;
+/**
+ * NIP-90 DVM job feedback (kind 7000).
+ * A single kind used for all feedback messages (processing, error, success,
+ * partial). Feedback events reference the original request via an `e` tag
+ * and carry a `status` tag indicating the current job state.
+ */
+declare const JOB_FEEDBACK_KIND = 7000;
+/**
+ * Text Generation DVM kind (kind 5100).
+ * Reference DVM kind for the TOON protocol. Used for general-purpose
+ * text generation tasks (e.g., LLM inference, summarization, Q&A).
+ */
+declare const TEXT_GENERATION_KIND = 5100;
+/**
+ * Image Generation DVM kind (kind 5200).
+ * Used for image generation tasks (e.g., text-to-image, image editing).
+ * Optional provider support -- not all nodes are required to handle this kind.
+ */
+declare const IMAGE_GENERATION_KIND = 5200;
+/**
+ * Text-to-Speech DVM kind (kind 5300).
+ * Used for text-to-speech conversion tasks.
+ * Optional provider support -- not all nodes are required to handle this kind.
+ */
+declare const TEXT_TO_SPEECH_KIND = 5300;
+/**
+ * Translation DVM kind (kind 5302).
+ * Used for language translation tasks.
+ * Optional provider support -- not all nodes are required to handle this kind.
+ */
+declare const TRANSLATION_KIND = 5302;
+
+/**
+ * TypeScript interfaces for ILP-related Nostr events.
+ */
+/**
+ * ILP Peer Info - Published as kind 10032 event.
+ * Contains information needed to establish an ILP peering relationship.
+ */
+interface IlpPeerInfo {
+    /** Nostr pubkey of the peer (64-char hex) */
+    pubkey?: string;
+    /** ILP address of the peer's connector (e.g., "g.example.connector") */
+    ilpAddress: string;
+    /** BTP WebSocket endpoint URL for packet exchange */
+    btpEndpoint: string;
+    /** Optional BLS HTTP endpoint for direct packet delivery (bootstrap only) */
+    blsHttpEndpoint?: string;
+    /** @deprecated Use supportedChains instead. Kept for backward compatibility. */
+    settlementEngine?: string;
+    /** Asset code for the peering relationship (e.g., "USD", "XRP") */
+    assetCode: string;
+    /** Asset scale - number of decimal places (e.g., 9 for XRP, 6 for USD cents) */
+    assetScale: number;
+    /** Supported settlement chain identifiers in {blockchain}:{network}:{chainId} format (e.g., ["evm:base:8453", "xrp:mainnet"]) */
+    supportedChains?: string[];
+    /** Maps chain identifier to the peer's settlement address on that chain */
+    settlementAddresses?: Record<string, string>;
+    /** Maps chain identifier to preferred token contract address */
+    preferredTokens?: Record<string, string>;
+    /** Maps chain identifier to TokenNetwork contract address (EVM-specific) */
+    tokenNetworks?: Record<string, string>;
+}
+/**
+ * Subscription handle for real-time event updates.
+ * Returned by subscription methods to allow cleanup.
+ */
+interface Subscription {
+    /** Stops receiving updates and closes the underlying relay subscription */
+    unsubscribe(): void;
+}
+/**
+ * Parameters for opening a payment channel via the connector Admin API.
+ */
+interface OpenChannelParams {
+    /** Connector peer identifier */
+    peerId: string;
+    /** Settlement chain identifier (e.g., "evm:base:8453") */
+    chain: string;
+    /** Token contract address on the chain */
+    token?: string;
+    /** TokenNetwork contract address (EVM-specific) */
+    tokenNetwork?: string;
+    /** Peer's settlement address on the chain */
+    peerAddress: string;
+    /** Initial deposit amount */
+    initialDeposit?: string;
+    /** Challenge period in seconds */
+    settlementTimeout?: number;
+}
+/**
+ * Result of opening a payment channel.
+ */
+interface OpenChannelResult {
+    /** Unique channel identifier */
+    channelId: string;
+    /** Channel status after open request */
+    status: string;
+}
+/**
+ * State of a payment channel from the connector.
+ */
+interface ChannelState {
+    /** Unique channel identifier */
+    channelId: string;
+    /** Current channel status */
+    status: 'opening' | 'open' | 'closed' | 'settled';
+    /** Settlement chain identifier */
+    chain: string;
+}
+/**
+ * TEE Attestation content for kind:10033 events (Pattern 14).
+ * Contains attestation data from a Trusted Execution Environment.
+ */
+interface TeeAttestation {
+    /** Enclave type identifier (e.g., 'aws-nitro', 'marlin-oyster'). */
+    enclave: string;
+    /** Platform Configuration Register 0 (SHA-384 hex, 96 chars). */
+    pcr0: string;
+    /** Platform Configuration Register 1 (SHA-384 hex, 96 chars). */
+    pcr1: string;
+    /** Platform Configuration Register 2 (SHA-384 hex, 96 chars). */
+    pcr2: string;
+    /** Base64-encoded attestation document from the TEE platform. */
+    attestationDoc: string;
+    /** Attestation format version. */
+    version: string;
+}
+/**
+ * Interface for interacting with the connector's channel Admin API.
+ * Abstracts POST /admin/channels and GET /admin/channels/:channelId.
+ */
+interface ConnectorChannelClient {
+    /** Opens a new payment channel via POST /admin/channels */
+    openChannel(params: OpenChannelParams): Promise<OpenChannelResult>;
+    /** Gets channel state via GET /admin/channels/:channelId */
+    getChannelState(channelId: string): Promise<ChannelState>;
+}
+
+/**
+ * Parsers for ILP-related Nostr events.
+ */
+
+/**
+ * Validates a chain identifier string.
+ * Valid format: {blockchain}:{network} or {blockchain}:{network}:{chainId}
+ * Minimum 2 segments, maximum 3, separated by `:`. All segments must be non-empty.
+ *
+ * @param chainId - The chain identifier to validate
+ * @returns true if the chain identifier is valid
+ */
+declare function validateChainId(chainId: string): boolean;
+/**
+ * Parses a kind:10032 Nostr event into an IlpPeerInfo object.
+ *
+ * @param event - The Nostr event to parse
+ * @returns The parsed IlpPeerInfo object
+ * @throws InvalidEventError if the event is malformed or missing required fields
+ */
+declare function parseIlpPeerInfo(event: NostrEvent): IlpPeerInfo;
+
+/**
+ * Builders for ILP-related Nostr events.
+ */
+
+/**
+ * Builds and signs a kind:10032 Nostr event from IlpPeerInfo data.
+ *
+ * @param info - The ILP peer info to serialize into the event
+ * @param secretKey - The secret key to sign the event with
+ * @returns A signed Nostr event
+ */
+declare function buildIlpPeerInfoEvent(info: IlpPeerInfo, secretKey: Uint8Array): NostrEvent;
+
+/**
+ * Event builder and parser for kind:10036 Seed Relay List events.
+ *
+ * Kind 10036 is a NIP-16 replaceable event (kind 10000-19999) published to
+ * public Nostr relays. Relays store only the latest event per `pubkey + kind`.
+ * The `d` tag with value `toon-seed-list` is included as a content marker
+ * for filtering.
+ *
+ * Seed relay list events advertise relay nodes that can serve as bootstrap
+ * entry points for new network participants.
+ */
+
+/** Content payload for a kind:10036 Seed Relay List event. */
+interface SeedRelayEntry {
+    /** WebSocket URL of the relay (wss:// for production, ws:// for dev). */
+    url: string;
+    /** Nostr pubkey of the relay operator (64-char lowercase hex). */
+    pubkey: string;
+    /** Optional metadata. */
+    metadata?: {
+        region?: string;
+        version?: string;
+        services?: string[];
+    };
+}
+/**
+ * Builds a kind:10036 Seed Relay List event (NIP-16 replaceable).
+ * Uses 'd' tag with value 'toon-seed-list' for replaceable event pattern.
+ *
+ * @param secretKey - The secret key to sign the event with.
+ * @param entries - The seed relay entries to include.
+ * @returns A signed Nostr event.
+ */
+declare function buildSeedRelayListEvent(secretKey: Uint8Array, entries: SeedRelayEntry[]): NostrEvent;
+/**
+ * Parses a kind:10036 event content into SeedRelayEntry[].
+ * Validates URLs (WebSocket scheme prefix) and pubkeys (64-char hex).
+ * Malformed entries are silently skipped (graceful degradation).
+ *
+ * @param event - The Nostr event to parse.
+ * @returns An array of valid SeedRelayEntry objects.
+ */
+declare function parseSeedRelayList(event: NostrEvent): SeedRelayEntry[];
+
+/**
+ * Event builder and parser for kind:10035 Service Discovery events.
+ *
+ * Kind 10035 is a NIP-16 replaceable event (kind 10000-19999) published to
+ * the local relay and optionally to peers. Relays store only the latest event
+ * per `pubkey + kind`. The `d` tag with value `toon-service-discovery` is
+ * included as a content marker for filtering.
+ *
+ * Service discovery events advertise a node's capabilities, pricing, and
+ * endpoints so that clients and AI agents can programmatically discover
+ * available services.
+ */
+
+/**
+ * Structured skill descriptor for DVM service discovery.
+ *
+ * Embedded in kind:10035 events to advertise DVM capabilities.
+ * Enables programmatic agent-to-agent service discovery: agents
+ * can read `inputSchema` to construct valid Kind 5xxx job requests
+ * without prior knowledge of the provider's capabilities.
+ *
+ * The `attestation` field is a placeholder for Epic 6 TEE integration
+ * (Story 6.3: TEE-attested DVM results).
+ */
+interface SkillDescriptor {
+    /** Service identifier (e.g., 'toon-dvm'). */
+    name: string;
+    /** Schema version (e.g., '1.0'). */
+    version: string;
+    /** Supported DVM Kind 5xxx numbers (e.g., [5100, 5200]). */
+    kinds: number[];
+    /** Capability list (e.g., ['text-generation', 'streaming']). */
+    features: string[];
+    /** JSON Schema draft-07 object describing job request parameters. */
+    inputSchema: Record<string, unknown>;
+    /** Kind number (as string) -> USDC micro-units cost (as string). */
+    pricing: Record<string, string>;
+    /** Available AI models (e.g., ['gpt-4', 'claude-3']). */
+    models?: string[];
+    /** Placeholder for Epic 6 TEE attestation integration. */
+    attestation?: Record<string, unknown>;
+}
+/** Content payload for a kind:10035 Service Discovery event. */
+interface ServiceDiscoveryContent {
+    /** Service type identifier (e.g., 'relay', 'rig'). */
+    serviceType: string;
+    /** ILP address of the node's connector. */
+    ilpAddress: string;
+    /** Pricing configuration. */
+    pricing: {
+        /** Base price per byte in smallest token unit. */
+        basePricePerByte: number;
+        /** Payment token symbol (e.g., 'USDC'). */
+        currency: string;
+    };
+    /**
+     * x402 endpoint configuration.
+     * Omitted entirely when x402 is disabled (not set to `{ enabled: false }`).
+     */
+    x402?: {
+        /** Whether x402 is enabled. */
+        enabled: boolean;
+        /** HTTP endpoint path (e.g., '/publish'). */
+        endpoint?: string;
+    };
+    /** Nostr event kinds this node accepts for storage. */
+    supportedKinds: number[];
+    /** Capabilities advertised by this node (e.g., ['relay', 'x402']). */
+    capabilities: string[];
+    /** Chain preset name (e.g., 'anvil', 'arbitrum-one'). */
+    chain: string;
+    /** Node software version. */
+    version: string;
+    /**
+     * Optional DVM skill descriptor.
+     * Present when the node has DVM handlers registered; omitted otherwise
+     * (backward compatible with pre-DVM kind:10035 events).
+     */
+    skill?: SkillDescriptor;
+}
+/**
+ * Builds a kind:10035 Service Discovery event (NIP-16 replaceable).
+ * Kind 10035 is in the 10000-19999 replaceable range (NIP-16).
+ * Relays store only the latest event per pubkey + kind.
+ * Includes 'd' tag with value 'toon-service-discovery' as a content marker.
+ *
+ * @param content - The service discovery payload.
+ * @param secretKey - The secret key to sign the event with.
+ * @returns A signed Nostr event.
+ */
+declare function buildServiceDiscoveryEvent(content: ServiceDiscoveryContent, secretKey: Uint8Array): NostrEvent;
+/**
+ * Parses a kind:10035 event content into ServiceDiscoveryContent.
+ * Validates required fields. Returns null for malformed content.
+ *
+ * @param event - The Nostr event to parse.
+ * @returns The parsed content, or null if invalid.
+ */
+declare function parseServiceDiscovery(event: NostrEvent): ServiceDiscoveryContent | null;
+
+/**
+ * Event builder and parser for kind:10033 TEE Attestation events.
+ *
+ * Kind 10033 is a NIP-16 replaceable event (kind 10000-19999) published by
+ * nodes running in a Trusted Execution Environment (TEE). Relays store only
+ * the latest event per `pubkey + kind`. No `d` tag is needed -- NIP-16
+ * replaces by pubkey + kind alone (unlike NIP-33 parameterized replaceable
+ * events in the 30000-39999 range).
+ *
+ * TEE attestation events contain PCR measurements, enclave type, and the
+ * base64-encoded attestation document from the TEE platform (e.g., AWS Nitro
+ * Enclaves via Marlin Oyster CVM).
+ *
+ * Content format (Pattern 14):
+ * ```json
+ * {
+ *   "enclave": "marlin-oyster",
+ *   "pcr0": "<sha384-hex-96-chars>",
+ *   "pcr1": "<sha384-hex-96-chars>",
+ *   "pcr2": "<sha384-hex-96-chars>",
+ *   "attestationDoc": "<base64-encoded>",
+ *   "version": "1.0.0"
+ * }
+ * ```
+ *
+ * Tags: ['relay', url], ['chain', chainId], ['expiry', unixTimestamp]
+ */
+
+/** Options for building a kind:10033 attestation event. */
+interface AttestationEventOptions {
+    /** WebSocket URL where this relay can be reached. */
+    relay: string;
+    /** Chain identifier (e.g., '42161' for Arbitrum One). */
+    chain: string;
+    /** Unix timestamp when this attestation expires. */
+    expiry: number;
+}
+/** Parsed result from a kind:10033 attestation event. */
+interface ParsedAttestation {
+    /** The attestation content fields. */
+    attestation: TeeAttestation;
+    /** WebSocket relay URL from the 'relay' tag. */
+    relay: string;
+    /** Chain identifier from the 'chain' tag. */
+    chain: string;
+    /** Expiry unix timestamp from the 'expiry' tag. */
+    expiry: number;
+}
+/**
+ * Builds a kind:10033 TEE Attestation event (NIP-16 replaceable).
+ *
+ * Content is `JSON.stringify(attestation)` per enforcement guideline 11.
+ * Tags include relay, chain, and expiry. No `d` tag is included -- NIP-16
+ * replaces by pubkey + kind alone.
+ *
+ * @param attestation - The TEE attestation content payload.
+ * @param secretKey - The secret key to sign the event with.
+ * @param options - Event options (relay URL, chain ID, expiry timestamp).
+ * @returns A signed Nostr event.
+ */
+declare function buildAttestationEvent(attestation: TeeAttestation, secretKey: Uint8Array, options: AttestationEventOptions): NostrEvent;
+/**
+ * Parses a kind:10033 event into a ParsedAttestation.
+ *
+ * Validates required content fields (enclave, pcr0-2, attestationDoc, version)
+ * and required tags (relay, chain, expiry). Returns `null` for malformed or
+ * missing data.
+ *
+ * When `options.verify` is `true`, performs strict validation:
+ * - PCR values must be 96-char lowercase hex (SHA-384)
+ * - attestationDoc must be non-empty valid base64
+ * Throws on invalid data when verify=true (adversarial input gate).
+ *
+ * @param event - The Nostr event to parse.
+ * @param options - Optional parse options. `verify: true` enables strict validation.
+ * @returns The parsed attestation, or null if invalid.
+ */
+declare function parseAttestation(event: NostrEvent, options?: {
+    verify?: boolean;
+}): ParsedAttestation | null;
+
+/**
+ * Event builders and parsers for NIP-90 DVM (Data Vending Machine) events.
+ *
+ * NIP-90 defines three event categories for the DVM protocol:
+ * - Kind 5000-5999: Job requests (each task type has a unique kind)
+ * - Kind 6000-6999: Job results (result kind = request kind + 1000)
+ * - Kind 7000: Job feedback (single kind for all status updates)
+ *
+ * TOON adopts NIP-90 kinds for cross-network interoperability with the
+ * broader Nostr DVM ecosystem. The `bid` and `amount` tags extend NIP-90
+ * with a third element ('usdc') for explicit currency declaration. NIP-90
+ * uses satoshis; TOON uses USDC micro-units (6 decimals).
+ *
+ * DVM events are standard Nostr events with specific kinds. They flow
+ * through the same SDK processing pipeline as all other events: shallow
+ * parse -> verify -> price -> dispatch. No special-casing required.
+ *
+ * Tag reference:
+ *
+ * Kind 5xxx (Job Request):
+ *   Required: ['i', data, type, relay?, marker?], ['bid', amount, 'usdc'], ['output', mimeType]
+ *   Optional: ['p', providerPubkey], ['param', key, value], ['relays', url1, ...]
+ *
+ * Kind 6xxx (Job Result):
+ *   Required: ['e', requestEventId], ['p', customerPubkey], ['amount', cost, 'usdc']
+ *   Content: result data
+ *
+ * Kind 7000 (Job Feedback):
+ *   Required: ['e', requestEventId], ['p', customerPubkey], ['status', statusValue]
+ *   Content: optional status details
+ */
+
+/**
+ * DVM job status values per NIP-90.
+ * - `'processing'`: Job is currently being processed.
+ * - `'error'`: Job failed with an error.
+ * - `'success'`: Job completed successfully.
+ * - `'partial'`: Job returned partial results (more to come).
+ */
+type DvmJobStatus = 'processing' | 'error' | 'success' | 'partial';
+/**
+ * Parameters for building a Kind 5xxx DVM job request event.
+ *
+ * The `kind` field must be in the 5000-5999 range (NIP-90 job request range).
+ * The `bid` field is the amount the requester is willing to pay, expressed as
+ * a string of USDC micro-units (6 decimals) for bigint compatibility.
+ */
+interface JobRequestParams {
+    /** Event kind in 5000-5999 range (e.g., 5100 for text generation). */
+    kind: number;
+    /** Input data with type classification. */
+    input: {
+        /** The input data (text, URL, event ID, etc.). */
+        data: string;
+        /** Input type identifier (e.g., 'text', 'url', 'event', 'job'). */
+        type: string;
+        /** Optional relay URL where the input data can be found. */
+        relay?: string;
+        /** Optional marker for input disambiguation. */
+        marker?: string;
+    };
+    /** Bid amount in USDC micro-units as string (bigint-compatible). */
+    bid: string;
+    /** Expected output MIME type (e.g., 'text/plain', 'image/png'). */
+    output: string;
+    /** Optional body text for the event content field. */
+    content?: string;
+    /** Optional 64-char hex pubkey of a specific target provider. */
+    targetProvider?: string;
+    /** Optional key-value parameters for the job (repeatable). */
+    params?: {
+        key: string;
+        value: string;
+    }[];
+    /** Optional preferred relay URLs for result delivery. */
+    relays?: string[];
+}
+/**
+ * Parameters for building a Kind 6xxx DVM job result event.
+ *
+ * The `kind` field must be in the 6000-6999 range. Result kind = request
+ * kind + 1000 (e.g., Kind 5100 request -> Kind 6100 result).
+ * The `amount` field is the actual compute cost in USDC micro-units.
+ */
+interface JobResultParams {
+    /** Event kind in 6000-6999 range (= request kind + 1000). */
+    kind: number;
+    /** 64-char hex event ID of the original Kind 5xxx request. */
+    requestEventId: string;
+    /** 64-char hex pubkey of the customer who posted the request. */
+    customerPubkey: string;
+    /** Compute cost in USDC micro-units as string (bigint-compatible). */
+    amount: string;
+    /** Result data (text, URL, etc.). */
+    content: string;
+}
+/**
+ * Parameters for building a Kind 7000 DVM job feedback event.
+ *
+ * Feedback events carry status updates about in-progress jobs. The `status`
+ * field must be one of the four NIP-90 status values.
+ */
+interface JobFeedbackParams {
+    /** 64-char hex event ID of the original Kind 5xxx request. */
+    requestEventId: string;
+    /** 64-char hex pubkey of the customer who posted the request. */
+    customerPubkey: string;
+    /** Job status value. */
+    status: DvmJobStatus;
+    /** Optional status details or error message. */
+    content?: string;
+}
+/**
+ * Parsed result from a Kind 5xxx DVM job request event.
+ */
+interface ParsedJobRequest {
+    /** Event kind (5000-5999). */
+    kind: number;
+    /** Input data with type classification. */
+    input: {
+        /** The input data. */
+        data: string;
+        /** Input type identifier. */
+        type: string;
+        /** Optional relay URL. */
+        relay?: string;
+        /** Optional marker. */
+        marker?: string;
+    };
+    /** Bid amount in USDC micro-units as string. */
+    bid: string;
+    /** Expected output MIME type. */
+    output: string;
+    /** Event content field (may be empty string). */
+    content: string;
+    /** Target provider pubkey if this is a targeted request. */
+    targetProvider?: string;
+    /** Key-value parameters (may be empty array). */
+    params: {
+        key: string;
+        value: string;
+    }[];
+    /** Preferred relay URLs (may be empty array). */
+    relays: string[];
+}
+/**
+ * Parsed result from a Kind 6xxx DVM job result event.
+ */
+interface ParsedJobResult {
+    /** Event kind (6000-6999). */
+    kind: number;
+    /** Event ID of the original request. */
+    requestEventId: string;
+    /** Pubkey of the customer who posted the request. */
+    customerPubkey: string;
+    /** Compute cost in USDC micro-units as string. */
+    amount: string;
+    /** Result data from the content field. */
+    content: string;
+}
+/**
+ * Parsed result from a Kind 7000 DVM job feedback event.
+ */
+interface ParsedJobFeedback {
+    /** Event ID of the original request. */
+    requestEventId: string;
+    /** Pubkey of the customer who posted the request. */
+    customerPubkey: string;
+    /** Job status value. */
+    status: DvmJobStatus;
+    /** Status details from the content field (may be empty string). */
+    content: string;
+}
+/**
+ * Builds a Kind 5xxx DVM job request event (NIP-90).
+ *
+ * Constructs a signed Nostr event with NIP-90 required tags: `i` (input),
+ * `bid` (payment offer), and `output` (expected MIME type). Optional tags
+ * include `p` (target provider), `param` (key-value pairs), and `relays`
+ * (preferred relay URLs).
+ *
+ * @param params - The job request parameters.
+ * @param secretKey - The secret key to sign the event with.
+ * @returns A signed Nostr event.
+ * @throws ToonError if required params are missing or kind is out of range.
+ */
+declare function buildJobRequestEvent(params: JobRequestParams, secretKey: Uint8Array): NostrEvent;
+/**
+ * Builds a Kind 6xxx DVM job result event (NIP-90).
+ *
+ * Constructs a signed Nostr event with NIP-90 required tags: `e` (request
+ * reference), `p` (customer pubkey), and `amount` (compute cost). The
+ * content field carries the result data.
+ *
+ * @param params - The job result parameters.
+ * @param secretKey - The secret key to sign the event with.
+ * @returns A signed Nostr event.
+ * @throws ToonError if required params are missing or kind is out of range.
+ */
+declare function buildJobResultEvent(params: JobResultParams, secretKey: Uint8Array): NostrEvent;
+/**
+ * Builds a Kind 7000 DVM job feedback event (NIP-90).
+ *
+ * Constructs a signed Nostr event with NIP-90 required tags: `e` (request
+ * reference), `p` (customer pubkey), and `status` (job state). The content
+ * field carries optional status details or error messages.
+ *
+ * @param params - The job feedback parameters.
+ * @param secretKey - The secret key to sign the event with.
+ * @returns A signed Nostr event.
+ * @throws ToonError if required params are missing or status is invalid.
+ */
+declare function buildJobFeedbackEvent(params: JobFeedbackParams, secretKey: Uint8Array): NostrEvent;
+/**
+ * Parses a Kind 5xxx event into a ParsedJobRequest.
+ *
+ * Validates the event kind is in the 5000-5999 range and extracts required
+ * NIP-90 tags: `i` (input), `bid` (amount + currency), and `output` (MIME
+ * type). Also extracts optional tags: `p` (target provider), `param`
+ * (key-value pairs), and `relays` (preferred URLs).
+ *
+ * Returns `null` for malformed events (missing required tags, invalid kind
+ * range). Follows the lenient parse pattern established by
+ * `parseServiceDiscovery()` and `parseAttestation()`.
+ *
+ * @param event - The Nostr event to parse.
+ * @returns The parsed job request, or null if invalid.
+ */
+declare function parseJobRequest(event: NostrEvent): ParsedJobRequest | null;
+/**
+ * Parses a Kind 6xxx event into a ParsedJobResult.
+ *
+ * Validates the event kind is in the 6000-6999 range and extracts required
+ * NIP-90 tags: `e` (request event ID), `p` (customer pubkey), and `amount`
+ * (compute cost + currency).
+ *
+ * Returns `null` for malformed events. Follows the lenient parse pattern.
+ *
+ * @param event - The Nostr event to parse.
+ * @returns The parsed job result, or null if invalid.
+ */
+declare function parseJobResult(event: NostrEvent): ParsedJobResult | null;
+/**
+ * Parses a Kind 7000 event into a ParsedJobFeedback.
+ *
+ * Validates the event kind is exactly 7000 and extracts required NIP-90
+ * tags: `e` (request event ID), `p` (customer pubkey), and `status`
+ * (job state). The status value must be one of: `'processing'`, `'error'`,
+ * `'success'`, `'partial'`.
+ *
+ * Returns `null` for malformed events or invalid status values.
+ * Follows the lenient parse pattern.
+ *
+ * @param event - The Nostr event to parse.
+ * @returns The parsed job feedback, or null if invalid.
+ */
+declare function parseJobFeedback(event: NostrEvent): ParsedJobFeedback | null;
+
+/**
+ * Peer discovery using Nostr NIP-02 follow lists.
+ */
+
+/**
+ * Discovers ILP peers by querying Nostr relays for NIP-02 follow lists.
+ */
+declare class NostrPeerDiscovery {
+    private readonly relayUrls;
+    private readonly pool;
+    /**
+     * Creates a new NostrPeerDiscovery instance.
+     *
+     * @param relayUrls - Array of relay WebSocket URLs to query
+     * @param pool - Optional SimplePool instance (creates new one if not provided)
+     */
+    constructor(relayUrls: string[], pool?: SimplePool);
+    /**
+     * Retrieves the list of pubkeys that a given pubkey follows.
+     *
+     * Queries NIP-02 kind:3 events from configured relays and returns
+     * the followed pubkeys from the most recent event.
+     *
+     * @param pubkey - The 64-character hex pubkey to get follows for
+     * @returns Array of followed pubkeys (deduplicated)
+     * @throws PeerDiscoveryError if pubkey format is invalid
+     */
+    getFollows(pubkey: string): Promise<string[]>;
+    /**
+     * Discovers ILP peers by querying follow list and their ILP peer info events.
+     *
+     * For each followed pubkey, queries kind:10032 events to retrieve ILP connection info.
+     * Peers without kind:10032 events or with malformed events are silently excluded.
+     *
+     * @param pubkey - The 64-character hex pubkey to discover peers for
+     * @returns Map of pubkey → IlpPeerInfo for peers with valid ILP info
+     * @throws PeerDiscoveryError if pubkey format is invalid
+     */
+    discoverPeers(pubkey: string): Promise<Map<string, IlpPeerInfo>>;
+    /**
+     * Subscribes to ILP peer info updates from followed pubkeys.
+     *
+     * Sets up a real-time subscription for kind:10032 events from all pubkeys
+     * that the given pubkey follows. The callback is invoked whenever a new
+     * or updated ILP peer info event is received.
+     *
+     * @param pubkey - The 64-character hex pubkey whose follows to monitor
+     * @param callback - Function called with (peerPubkey, parsedInfo) for each update
+     * @returns Subscription object with unsubscribe() method
+     * @throws PeerDiscoveryError if pubkey format is invalid
+     */
+    subscribeToPeerUpdates(pubkey: string, callback: (pubkey: string, info: IlpPeerInfo) => void): Promise<Subscription>;
+}
+
+/**
+ * Genesis peer loader for bootstrapping new nodes into the network.
+ *
+ * Loads well-known genesis peers from a bundled JSON file and supports
+ * merging with runtime-provided additional peers.
+ */
+/** A genesis peer entry used for network bootstrapping. */
+interface GenesisPeer {
+    pubkey: string;
+    relayUrl: string;
+    ilpAddress: string;
+    btpEndpoint: string;
+}
+/** Load and validate genesis peers from the bundled JSON file. */
+declare function loadGenesisPeers(): GenesisPeer[];
+/** Parse and validate additional peers from a JSON string. */
+declare function loadAdditionalPeers(json: string): GenesisPeer[];
+/** Load genesis peers and optionally merge with additional peers. */
+declare function loadAllPeers(additionalPeersJson?: string): GenesisPeer[];
+declare const GenesisPeerLoader: {
+    readonly loadGenesisPeers: typeof loadGenesisPeers;
+    readonly loadAdditionalPeers: typeof loadAdditionalPeers;
+    readonly loadAllPeers: typeof loadAllPeers;
+};
+
+/**
+ * ArDrive-based peer registry for permanent, decentralized storage
+ * of ILP peer info on Arweave.
+ *
+ * Read path: queries Arweave GraphQL gateway (free, no wallet needed).
+ * Write path: uploads via @ardrive/turbo-sdk (caller provides authenticated client).
+ */
+
+declare function fetchPeers(gatewayUrl?: string): Promise<Map<string, IlpPeerInfo>>;
+declare function publishPeerInfo(peerInfo: IlpPeerInfo, pubkey: string, turboClient: TurboAuthenticatedClient): Promise<string>;
+declare const ArDrivePeerRegistry: {
+    readonly fetchPeers: typeof fetchPeers;
+    readonly publishPeerInfo: typeof publishPeerInfo;
+};
+
+/**
+ * Social graph-based peer discovery (passive).
+ *
+ * Subscribes to NIP-02 follow list changes and emits events
+ * for new follows and unfollows. Does NOT auto-peer — the caller
+ * decides when and whether to initiate peering.
+ */
+
+/**
+ * Events emitted by SocialPeerDiscovery.
+ */
+type SocialDiscoveryEvent = {
+    type: 'social:follow-discovered';
+    pubkey: string;
+} | {
+    type: 'social:follow-removed';
+    pubkey: string;
+};
+/**
+ * Listener callback for social discovery events.
+ */
+type SocialDiscoveryEventListener = (event: SocialDiscoveryEvent) => void;
+/**
+ * Configuration for SocialPeerDiscovery.
+ */
+interface SocialPeerDiscoveryConfig {
+    /** Relays to subscribe to for kind:3 events */
+    relayUrls: string[];
+}
+/**
+ * Passive social graph peer discovery.
+ *
+ * Subscribes to NIP-02 kind:3 follow list events and emits:
+ * - `social:follow-discovered` when a new pubkey appears in the follow list
+ * - `social:follow-removed` when a pubkey disappears from the follow list
+ *
+ * The caller decides when to peer via `on()` listener.
+ */
+declare class SocialPeerDiscovery {
+    private readonly config;
+    private readonly pubkey;
+    private readonly pool;
+    private readonly listeners;
+    private previousFollows;
+    private started;
+    /**
+     * Creates a new SocialPeerDiscovery instance.
+     *
+     * @param config - Discovery configuration
+     * @param secretKey - Our Nostr secret key (used to derive pubkey)
+     * @param pool - Optional SimplePool instance (creates new one if not provided)
+     */
+    constructor(config: SocialPeerDiscoveryConfig, secretKey: Uint8Array, pool?: SimplePool);
+    /**
+     * Register a listener for social discovery events.
+     */
+    on(listener: SocialDiscoveryEventListener): void;
+    /**
+     * Remove a previously registered listener.
+     */
+    off(listener: SocialDiscoveryEventListener): void;
+    /**
+     * Start subscribing to kind:3 follow list events for the node's pubkey.
+     *
+     * @returns Subscription with unsubscribe() to stop discovery
+     * @throws PeerDiscoveryError if already started
+     */
+    start(): Subscription;
+    /**
+     * Process a follow list update by diffing against previous state.
+     */
+    private processFollowListUpdate;
+    /**
+     * Emit an event to all registered listeners.
+     */
+    private emit;
+}
+
+/**
+ * Seed Relay Discovery -- discovers peers via kind:10036 seed relay list events.
+ *
+ * Uses raw `ws` WebSocket connections to avoid the `ReferenceError: window is
+ * not defined` issue that occurs with nostr-tools pool utilities in Node.js
+ * containers.
+ *
+ * Discovery flow:
+ *   1. Connect to public Nostr relays and query for kind:10036 events.
+ *   2. Parse seed relay entries from kind:10036 event content.
+ *   3. Connect to seed relays sequentially (fallback on failure).
+ *   4. Subscribe to kind:10032 on the first connected seed relay.
+ *   5. Return discovered peers as IlpPeerInfo[].
+ */
+
+/** Configuration for seed relay discovery. */
+interface SeedRelayDiscoveryConfig {
+    /** Public Nostr relay URLs to query for kind:10036 events. */
+    publicRelays: string[];
+    /** Timeout for relay connections in ms (default: 10000). */
+    connectionTimeout?: number;
+    /** Timeout for kind:10036 queries in ms (default: 5000). */
+    queryTimeout?: number;
+}
+/** Result of seed relay discovery. */
+interface SeedRelayDiscoveryResult {
+    /** Number of seed relays successfully connected to. */
+    seedRelaysConnected: number;
+    /** Total seed relays attempted. */
+    attemptedSeeds: number;
+    /** WebSocket URLs of connected seed relays. */
+    connectedUrls: string[];
+    /** Peers discovered via kind:10032 from seed relays. */
+    discoveredPeers: IlpPeerInfo[];
+}
+/** Configuration for publishing a seed relay entry. */
+interface PublishSeedRelayConfig {
+    /** Secret key for signing the event. */
+    secretKey: Uint8Array;
+    /** This node's WebSocket relay URL (e.g., wss://my-relay.example.com). */
+    relayUrl: string;
+    /** Public Nostr relay URLs to publish to. */
+    publicRelays: string[];
+    /** Optional metadata. */
+    metadata?: SeedRelayEntry['metadata'];
+}
+/**
+ * Discovers peers via the seed relay list model.
+ *
+ * Queries public Nostr relays for kind:10036 events, parses seed relay
+ * entries, connects to seed relays, and subscribes to kind:10032 events
+ * to discover network peers.
+ */
+declare class SeedRelayDiscovery {
+    private readonly config;
+    private readonly connectionTimeout;
+    private readonly queryTimeout;
+    private readonly openSockets;
+    constructor(config: SeedRelayDiscoveryConfig);
+    /**
+     * Discover peers via seed relay list.
+     *
+     * 1. Query publicRelays for kind:10036 events
+     * 2. Parse seed relay entries
+     * 3. Connect to seed relays sequentially (fallback on failure)
+     * 4. Subscribe to kind:10032 on connected seed relay
+     * 5. Return discovered peers
+     *
+     * @throws PeerDiscoveryError if all seed relays are exhausted
+     */
+    discover(): Promise<SeedRelayDiscoveryResult>;
+    /**
+     * Stop discovery and close all open WebSocket connections.
+     */
+    close(): Promise<void>;
+    /**
+     * Query public relays for kind:10036 events and parse seed relay entries.
+     */
+    private querySeedRelayLists;
+    /**
+     * Deduplicate seed relay entries by URL, keeping the first occurrence.
+     */
+    private deduplicateByUrl;
+}
+/**
+ * Publish a kind:10036 event advertising this node as a seed relay.
+ * Connects to each publicRelay and publishes the event.
+ * Returns the number of relays the event was published to.
+ *
+ * @param config - Configuration for publishing the seed relay entry.
+ * @returns The count of successful publishes and the event ID.
+ */
+declare function publishSeedRelayEntry(config: PublishSeedRelayConfig): Promise<{
+    publishedTo: number;
+    eventId: string;
+}>;
+
+/**
+ * Pure functions for settlement chain negotiation.
+ * No I/O or side effects — used during peer registration to determine
+ * the best matching settlement chain and token.
+ */
+/**
+ * Negotiates the best matching settlement chain between requester and responder.
+ *
+ * Preference order:
+ * 1. Chain in intersection with requester's preferred token
+ * 2. Chain in intersection with responder's preferred token
+ * 3. First chain in intersection (requester's order preserved)
+ *
+ * @param requesterChains - Chain identifiers the requester supports
+ * @param responderChains - Chain identifiers the responder supports
+ * @param requesterPreferredTokens - Requester's preferred tokens by chain
+ * @param responderPreferredTokens - Responder's preferred tokens by chain
+ * @returns The negotiated chain identifier, or null if no intersection
+ */
+declare function negotiateSettlementChain(requesterChains: string[], responderChains: string[], requesterPreferredTokens?: Record<string, string>, responderPreferredTokens?: Record<string, string>): string | null;
+/**
+ * Resolves which token to use for a given chain.
+ *
+ * Priority: requester's preference > responder's preference > undefined
+ *
+ * @param chain - The chain identifier to resolve token for
+ * @param requesterPreferredTokens - Requester's preferred tokens by chain
+ * @param responderPreferredTokens - Responder's preferred tokens by chain
+ * @returns The token address, or undefined if neither party has a preference
+ */
+declare function resolveTokenForChain(chain: string, requesterPreferredTokens?: Record<string, string>, responderPreferredTokens?: Record<string, string>): string | undefined;
+
+/**
+ * Bootstrap state machine types, event types, and client interfaces.
+ */
+
+/**
+ * A peer discovered via kind:10032 relay events but not yet peered with.
+ */
+interface DiscoveredPeer {
+    /** Nostr pubkey of the discovered peer (64-char hex) */
+    pubkey: string;
+    /** Connector peer ID (e.g., "nostr-aabb11cc22dd33ee") */
+    peerId: string;
+    /** Parsed ILP peer info from the kind:10032 event */
+    peerInfo: IlpPeerInfo;
+    /** Timestamp (seconds since epoch) when the peer was first discovered */
+    discoveredAt: number;
+}
+/**
+ * Represents a known peer for bootstrap.
+ */
+interface KnownPeer {
+    /** Nostr pubkey of the peer (64-char hex) */
+    pubkey: string;
+    /** WebSocket URL of the peer's Nostr relay */
+    relayUrl: string;
+    /** BTP WebSocket endpoint for direct connection during bootstrap */
+    btpEndpoint: string;
+}
+/**
+ * Result of a successful peer bootstrap.
+ */
+interface BootstrapResult {
+    /** The known peer that was bootstrapped with */
+    knownPeer: KnownPeer;
+    /** The peer's ILP info from their kind:10032 event */
+    peerInfo: IlpPeerInfo;
+    /** The ID used when registering with the connector (e.g., "nostr-aabb11cc22dd33ee") */
+    registeredPeerId: string;
+    /** Channel ID from unilateral channel opening */
+    channelId?: string;
+    /** Negotiated chain from local settlement negotiation */
+    negotiatedChain?: string;
+    /** Peer's settlement address */
+    settlementAddress?: string;
+}
+/**
+ * Callback interface for connector Admin API operations.
+ * Matches the connector admin API shape: POST /admin/peers
+ */
+interface ConnectorAdminClient {
+    /**
+     * Add a peer to the connector via the admin API.
+     * @param config - Peer configuration matching the connector admin API shape
+     */
+    addPeer(config: {
+        id: string;
+        url: string;
+        authToken: string;
+        routes?: {
+            prefix: string;
+            priority?: number;
+        }[];
+        settlement?: {
+            preference: string;
+            evmAddress?: string;
+            tokenAddress?: string;
+            tokenNetworkAddress?: string;
+            chainId?: number;
+            channelId?: string;
+            initialDeposit?: string;
+        };
+    }): Promise<void>;
+    /**
+     * Remove a peer from the connector via the admin API.
+     * Optional -- not all callers will implement peer removal.
+     * @param peerId - The peer ID to remove
+     */
+    removePeer?(peerId: string): Promise<void>;
+}
+/**
+ * Bootstrap phase states.
+ * Two-phase flow: discovering -> registering -> announcing -> ready | failed
+ */
+type BootstrapPhase = 'discovering' | 'registering' | 'announcing' | 'ready' | 'failed';
+/**
+ * Bootstrap events emitted during the bootstrap lifecycle.
+ */
+type BootstrapEvent = {
+    type: 'bootstrap:phase';
+    phase: BootstrapPhase;
+    previousPhase?: BootstrapPhase;
+} | {
+    type: 'bootstrap:peer-registered';
+    peerId: string;
+    peerPubkey: string;
+    ilpAddress: string;
+} | {
+    type: 'bootstrap:channel-opened';
+    peerId: string;
+    channelId: string;
+    negotiatedChain: string;
+} | {
+    type: 'bootstrap:settlement-failed';
+    peerId: string;
+    reason: string;
+} | {
+    type: 'bootstrap:announced';
+    peerId: string;
+    eventId: string;
+    amount: string;
+} | {
+    type: 'bootstrap:announce-failed';
+    peerId: string;
+    reason: string;
+} | {
+    type: 'bootstrap:ready';
+    peerCount: number;
+    channelCount: number;
+} | {
+    type: 'bootstrap:peer-discovered';
+    peerPubkey: string;
+    ilpAddress: string;
+} | {
+    type: 'bootstrap:peer-deregistered';
+    peerId: string;
+    peerPubkey: string;
+    reason: string;
+};
+/**
+ * Listener callback for bootstrap events.
+ */
+type BootstrapEventListener = (event: BootstrapEvent) => void;
+/**
+ * Result of sending an ILP packet via the connector.
+ * The connector may return either `accepted` or `fulfilled` as the
+ * success indicator. IlpClient normalizes to `accepted`.
+ */
+interface IlpSendResult {
+    accepted: boolean;
+    fulfillment?: string;
+    data?: string;
+    code?: string;
+    message?: string;
+}
+/**
+ * Client interface for sending ILP packets via the connector.
+ */
+interface IlpClient {
+    sendIlpPacket(params: {
+        destination: string;
+        amount: string;
+        data: string;
+        timeout?: number;
+    }): Promise<IlpSendResult>;
+    /**
+     * Optional: Send ILP packet with signed balance proof claim (BTP only).
+     * Falls back to sendIlpPacket if not implemented.
+     */
+    sendIlpPacketWithClaim?(params: {
+        destination: string;
+        amount: string;
+        data: string;
+        timeout?: number;
+    }, claim: unknown): Promise<IlpSendResult>;
+}
+/**
+ * @deprecated Use IlpClient instead
+ */
+type AgentRuntimeClient = IlpClient;
+/**
+ * Own settlement configuration for local chain selection during registration.
+ */
+interface SettlementConfig {
+    /** Chain identifiers this node supports */
+    supportedChains?: string[];
+    /** Maps chain identifier to this node's settlement address */
+    settlementAddresses?: Record<string, string>;
+    /** Maps chain identifier to this node's preferred token contract address */
+    preferredTokens?: Record<string, string>;
+    /** Maps chain identifier to TokenNetwork contract address (EVM only) */
+    tokenNetworks?: Record<string, string>;
+}
+/**
+ * Base configuration for the bootstrap service.
+ */
+interface BootstrapConfig {
+    /** List of known peers to bootstrap with */
+    knownPeers: KnownPeer[];
+    /** Timeout for relay queries in milliseconds (default: 5000) */
+    queryTimeout?: number;
+    /** Enable ArDrive peer lookup (default: true) */
+    ardriveEnabled?: boolean;
+    /** Default relay URL for ArDrive-sourced peers that lack relay URLs */
+    defaultRelayUrl?: string;
+}
+/**
+ * Extended configuration for the bootstrap service with ILP-first flow support.
+ */
+interface BootstrapServiceConfig extends BootstrapConfig {
+    /** Own settlement preferences for settlement during peer registration */
+    settlementInfo?: SettlementConfig;
+    /** This node's ILP address (for building ILP PREPARE destinations) */
+    ownIlpAddress?: string;
+    /** DI callback for TOON encoding (avoids circular dep) */
+    toonEncoder?: (event: NostrEvent) => Uint8Array;
+    /** DI callback for TOON decoding (avoids circular dep) */
+    toonDecoder?: (bytes: Uint8Array) => NostrEvent;
+    /** Static BTP secret for initial peer registration (before settlement) */
+    btpSecret?: string;
+    /** Base price per byte for ILP packet pricing (default: 10n) */
+    basePricePerByte?: bigint;
+}
+
+/**
+ * Bootstrap service for peer discovery and network initialization.
+ *
+ * Handles the initial peer discovery and registration process
+ * with known peers to bootstrap into the ILP network.
+ *
+ * Two-phase bootstrap:
+ * 1. Discover & Register: Load peers, query relays for kind:10032,
+ *    register with connector, select chain locally, open channel unilaterally
+ * 2. Announce: Publish own kind:10032 as paid ILP PREPARE
+ */
+
+/**
+ * Error thrown when bootstrap operations fail.
+ */
+declare class BootstrapError extends ToonError {
+    constructor(message: string, cause?: Error);
+}
+/**
+ * Service for bootstrapping into the ILP network via known Nostr peers.
+ *
+ * The bootstrap process:
+ * Phase 1 (Discover & Register): Load peers from config, ArDrive, and env var.
+ *          For each peer, query their relay for kind:10032 (ILP Peer Info).
+ *          Register peer via connector admin API.
+ *          Select chain locally and open channel unilaterally.
+ * Phase 2 (Announce): Publish own kind:10032 as paid ILP PREPARE.
+ */
+declare class BootstrapService {
+    private readonly config;
+    private readonly secretKey;
+    private readonly pubkey;
+    private readonly ownIlpInfo;
+    private readonly pool;
+    private connectorAdmin?;
+    private channelClient?;
+    private claimSigner?;
+    private readonly ilpClient?;
+    private readonly settlementInfo?;
+    private readonly ownIlpAddress?;
+    private readonly toonEncoder?;
+    private readonly toonDecoder?;
+    private readonly basePricePerByte;
+    private listeners;
+    private phase;
+    /**
+     * Creates a new BootstrapService instance.
+     *
+     * @param config - Bootstrap configuration with known peers and optional ILP-first settings
+     * @param secretKey - Our Nostr secret key for signing events
+     * @param ownIlpInfo - Our ILP peer info to publish
+     * @param pool - Optional SimplePool instance (creates new one if not provided)
+     */
+    constructor(config: BootstrapServiceConfig, secretKey: Uint8Array, ownIlpInfo: IlpPeerInfo, pool?: SimplePool);
+    /**
+     * Set the ILP client for sending packets via the connector.
+     * Kept separate from constructor for backward compatibility with existing code
+     * that creates the client after construction.
+     */
+    setIlpClient(client: IlpClient): void;
+    /**
+     * @deprecated Use setIlpClient instead
+     */
+    setAgentRuntimeClient(client: IlpClient): void;
+    /**
+     * Set the connector admin client for adding peers/routes.
+     */
+    setConnectorAdmin(admin: ConnectorAdminClient): void;
+    /**
+     * Set the channel client for opening payment channels.
+     */
+    setChannelClient(client: ConnectorChannelClient): void;
+    /**
+     * Set the claim signer for creating signed balance proofs.
+     * Used by clients to sign payment channel claims for ILP packets.
+     */
+    setClaimSigner(signer: (channelId: string, amount: bigint) => Promise<unknown>): void;
+    /**
+     * Get the current bootstrap phase.
+     */
+    getPhase(): BootstrapPhase;
+    /**
+     * Register an event listener.
+     */
+    on(listener: BootstrapEventListener): void;
+    /**
+     * Unregister an event listener.
+     */
+    off(listener: BootstrapEventListener): void;
+    /**
+     * Emit a bootstrap event to all listeners.
+     */
+    private emit;
+    /**
+     * Transition to a new phase, emitting phase change event.
+     */
+    private setPhase;
+    /**
+     * Load peers from genesis config, ArDrive, and optional env var JSON.
+     * Merges all sources, deduplicating by pubkey (ArDrive overrides genesis for matching pubkeys).
+     */
+    loadPeers(additionalPeersJson?: string): Promise<GenesisPeer[]>;
+    /**
+     * Bootstrap with all known peers.
+     *
+     * Loads peers from genesis config, ArDrive, and optional env var JSON,
+     * then attempts to bootstrap with each peer in order.
+     * Returns results for successfully bootstrapped peers.
+     * Continues to next peer on failure.
+     *
+     * @param additionalPeersJson - Optional JSON string of additional peers to merge
+     * @returns Array of successful bootstrap results
+     */
+    bootstrap(additionalPeersJson?: string): Promise<BootstrapResult[]>;
+    /**
+     * Bootstrap with a single known peer.
+     *
+     * @param knownPeer - The known peer to bootstrap with
+     * @returns Bootstrap result with peer info and registered peer ID
+     * @throws BootstrapError if pubkey is invalid or peer info query fails
+     */
+    bootstrapWithPeer(knownPeer: KnownPeer): Promise<BootstrapResult>;
+    /**
+     * Announce own kind:10032 as paid ILP PREPARE (Phase 2).
+     */
+    private announceViaIlp;
+    /**
+     * Query a peer's relay for their kind:10032 ILP Peer Info event.
+     * Uses direct WebSocket connection for reliable container-to-container communication.
+     */
+    private queryPeerInfo;
+    /**
+     * Add a peer to the connector via Admin API.
+     */
+    private addPeerToConnector;
+    /**
+     * Publish our own kind:10032 ILP Peer Info to a relay.
+     */
+    private publishOurInfo;
+    /**
+     * Query a peer's relay for other peers' kind:10032 events.
+     *
+     * Used after bootstrapping to discover additional peers
+     * that have also published to the bootstrap node's relay.
+     *
+     * @param relayUrl - The relay URL to query
+     * @param excludePubkeys - Pubkeys to exclude from results (e.g., our own, known peers)
+     * @returns Map of pubkey to IlpPeerInfo for discovered peers
+     */
+    discoverPeersViaRelay(relayUrl: string, excludePubkeys?: string[]): Promise<Map<string, IlpPeerInfo>>;
+    /**
+     * Get our pubkey.
+     */
+    getPubkey(): string;
+    /**
+     * Publish our ILP info to a specific relay.
+     *
+     * @param relayUrl - The relay URL to publish to (defaults to 'ws://localhost:7100')
+     */
+    publishToRelay(relayUrl?: string): Promise<void>;
+}
+
+/**
+ * Discovery tracker for processing kind:10032 events and managing peer discovery.
+ *
+ * Unlike RelayMonitor, the tracker does NOT own a subscription — callers feed
+ * events in via processEvent(). This enables use from any event source:
+ * relay subscriptions, ILP handlers, or test harnesses.
+ */
+
+/**
+ * Configuration for creating a DiscoveryTracker.
+ */
+interface DiscoveryTrackerConfig {
+    /** Nostr secret key for deriving own pubkey (excluded from discovery) */
+    secretKey: Uint8Array;
+    /** Own settlement preferences for local chain negotiation */
+    settlementInfo?: SettlementConfig;
+}
+/**
+ * Discovery tracker interface — processes kind:10032 events and manages
+ * peer discovery state without owning a subscription.
+ */
+interface DiscoveryTracker {
+    /** Process a kind:10032 event for discovery. Called by relay subscription or ILP handler. */
+    processEvent(event: NostrEvent): void;
+    /** Explicitly peer with a discovered peer (register + open channel). */
+    peerWith(pubkey: string): Promise<void>;
+    /** Get discovered peers not yet peered with. */
+    getDiscoveredPeers(): DiscoveredPeer[];
+    /** Check if a pubkey has been actively peered with. */
+    isPeered(pubkey: string): boolean;
+    /** Count of registered (peered) peers. */
+    getPeerCount(): number;
+    /** Count of all discovered peers (including peered). */
+    getDiscoveredCount(): number;
+    /** Register an event listener. */
+    on(listener: BootstrapEventListener): void;
+    /** Unregister an event listener. */
+    off(listener: BootstrapEventListener): void;
+    /** Set connector admin for peer registration (required before peerWith). */
+    setConnectorAdmin(admin: ConnectorAdminClient): void;
+    /** Set channel client for payment channel opening (optional). */
+    setChannelClient(client: ConnectorChannelClient): void;
+    /** Mark pubkeys as already-peered (e.g., from bootstrap phase). */
+    addExcludedPubkeys(pubkeys: string[]): void;
+}
+/**
+ * Create a discovery tracker that processes kind:10032 events.
+ *
+ * The tracker does not own a subscription — callers feed events in via
+ * processEvent(). It handles discovery, stale-event filtering,
+ * deregistration, and explicit peering via peerWith().
+ */
+declare function createDiscoveryTracker(config: DiscoveryTrackerConfig): DiscoveryTracker;
+
+/**
+ * HTTP client for sending ILP packets via the connector's POST /ilp/send endpoint.
+ */
+
+/**
+ * Creates an HTTP-based IlpClient that sends ILP packets via POST /ilp/send.
+ *
+ * @param baseUrl - Base URL of the connector (e.g., "http://localhost:3000")
+ * @returns An IlpClient instance
+ * @throws BootstrapError if baseUrl is not a valid URL
+ */
+declare function createHttpIlpClient$1(baseUrl: string): IlpClient;
+/**
+ * @deprecated Use createHttpIlpClient instead
+ */
+declare const createHttpRuntimeClient: typeof createHttpIlpClient$1;
+/**
+ * @deprecated Use createHttpIlpClient instead
+ */
+declare const createAgentRuntimeClient: typeof createHttpIlpClient$1;
+
+/**
+ * Direct (in-process) client for sending ILP packets via a ConnectorNode.
+ *
+ * Unlike the HTTP-based createHttpIlpClient(), this factory wraps a
+ * ConnectorNode's sendPacket() method as an IlpClient, enabling
+ * zero-latency embedded mode without network overhead.
+ */
+
+/**
+ * Parameters accepted by ConnectorNode.sendPacket().
+ */
+interface SendPacketParams {
+    /** ILP destination address */
+    destination: string;
+    /** Amount as BigInt (not string) */
+    amount: bigint;
+    /** Binary data (not base64 string) */
+    data: Uint8Array;
+    /** 32-byte SHA-256 execution condition */
+    executionCondition?: Uint8Array;
+    /**
+     * Packet expiration. Included for structural compatibility with ConnectorNode
+     * but is not set by the direct client — callers or the connector provide it
+     * if needed.
+     */
+    expiresAt?: Date;
+}
+/**
+ * Result returned by ConnectorNode.sendPacket().
+ *
+ * Accepts both string discriminants ('fulfill'/'reject') for backward
+ * compatibility with test mocks, and numeric PacketType enum values
+ * (13 = FULFILL, 14 = REJECT) used by @toon-protocol/connector@1.6.0+.
+ */
+type SendPacketResult = {
+    type: 'fulfill';
+    fulfillment: Uint8Array | Buffer;
+    data?: Uint8Array | Buffer;
+} | {
+    type: 13;
+    fulfillment: Uint8Array | Buffer;
+    data?: Uint8Array | Buffer;
+} | {
+    type: 'reject';
+    code: string;
+    message: string;
+    data?: Uint8Array | Buffer;
+} | {
+    type: 14;
+    code: string;
+    message: string;
+    data?: Uint8Array | Buffer;
+};
+/**
+ * Structural interface matching ConnectorNode's sendPacket() method.
+ *
+ * Consumers pass a `@toon-protocol/connector` ConnectorNode instance without
+ * needing to import `@toon-protocol/connector` as a dependency.
+ * TypeScript's structural type system handles compatibility automatically.
+ */
+interface ConnectorNodeLike {
+    sendPacket(params: SendPacketParams): Promise<SendPacketResult>;
+}
+/**
+ * Configuration options for the direct runtime client.
+ */
+interface DirectRuntimeClientConfig {
+    /**
+     * Optional callback for extracting the Nostr event ID from TOON-encoded data.
+     *
+     * When provided, the client computes
+     * `executionCondition = SHA256(SHA256(event.id))` and passes it to
+     * `sendPacket()`.
+     *
+     * When omitted, no executionCondition is set (connector uses its default).
+     *
+     * Note: this is intentionally a narrower type than
+     * `BootstrapServiceConfig.toonDecoder` (which returns a full `NostrEvent`).
+     * Only the `id` field is needed for condition computation, so the interface
+     * is minimal.
+     */
+    toonDecoder?: (bytes: Uint8Array) => {
+        id: string;
+    };
+}
+/**
+ * Creates an IlpClient that sends ILP packets by calling
+ * `connector.sendPacket()` directly (no HTTP).
+ *
+ * @param connector - A ConnectorNode-like object with a sendPacket() method
+ * @param config - Optional configuration (e.g., toonDecoder for condition computation)
+ * @returns An IlpClient instance
+ */
+declare function createDirectIlpClient(connector: ConnectorNodeLike, config?: DirectRuntimeClientConfig): IlpClient;
+/**
+ * @deprecated Use createDirectIlpClient instead
+ */
+declare const createDirectRuntimeClient: typeof createDirectIlpClient;
+
+/**
+ * Parameters for registering a peer on the connector.
+ * Maps to ConnectorNode.registerPeer() params in @toon-protocol/connector.
+ */
+interface RegisterPeerParams {
+    id: string;
+    url: string;
+    authToken?: string;
+    routes?: {
+        prefix: string;
+        priority?: number;
+    }[];
+    settlement?: Record<string, unknown>;
+}
+/**
+ * Structural interface for ConnectorNode admin methods.
+ *
+ * This is a structural interface — consumers pass an `@toon-protocol/connector`
+ * ConnectorNode instance without importing it as a dependency. The ConnectorNode's
+ * `registerPeer()` and `removePeer()` methods match this shape, allowing
+ * zero-dependency coupling for embedded mode.
+ */
+interface ConnectorAdminLike {
+    registerPeer(params: RegisterPeerParams): Promise<void>;
+    removePeer(peerId: string): Promise<void>;
+}
+/**
+ * Creates a ConnectorAdminClient that calls ConnectorNode methods directly
+ * instead of making HTTP requests.
+ *
+ * Used for embedded mode where the ConnectorNode runs in-process.
+ * The returned client conforms to the ConnectorAdminClient interface,
+ * making it a drop-in replacement for the HTTP-based admin client.
+ *
+ * @param connector - A ConnectorNode instance (or any object matching ConnectorAdminLike)
+ * @returns A ConnectorAdminClient that manages peers via direct function calls
+ *
+ * @example
+ * ```typescript
+ * import { ConnectorNode } from '@toon-protocol/connector';
+ * import { createDirectConnectorAdmin } from '@toon-protocol/core/bootstrap';
+ *
+ * const connector = new ConnectorNode({ ... });
+ * const adminClient = createDirectConnectorAdmin(connector);
+ *
+ * await adminClient.addPeer({
+ *   id: 'peer1',
+ *   url: 'btp+ws://peer1.example.com',
+ *   authToken: 'secret',
+ *   routes: [{ prefix: 'g.alice', priority: 1 }],
+ * });
+ * ```
+ */
+declare function createDirectConnectorAdmin(connector: ConnectorAdminLike): ConnectorAdminClient;
+
+/**
+ * Direct (in-process) client for payment channel operations via a ConnectorNode.
+ *
+ * Unlike HTTP-based channel clients, this factory wraps a ConnectorNode's
+ * openChannel() and getChannelState() methods as a ConnectorChannelClient,
+ * enabling zero-latency embedded mode without network overhead.
+ *
+ * Requires @toon-protocol/connector >=1.2.0 which exposes these methods
+ * as public API on ConnectorNode.
+ */
+
+/**
+ * Structural interface matching ConnectorNode's channel methods.
+ *
+ * Consumers pass an `@toon-protocol/connector` ConnectorNode instance without
+ * toon needing to import `@toon-protocol/connector` as a dependency.
+ * TypeScript's structural type system handles compatibility automatically.
+ */
+interface ConnectorChannelLike {
+    openChannel(params: {
+        peerId: string;
+        chain: string;
+        token?: string;
+        tokenNetwork?: string;
+        peerAddress: string;
+        initialDeposit?: string;
+        settlementTimeout?: number;
+    }): Promise<{
+        channelId: string;
+        status: string;
+    }>;
+    getChannelState(channelId: string): Promise<{
+        channelId: string;
+        status: 'opening' | 'open' | 'closed' | 'settled';
+        chain: string;
+    }>;
+}
+/**
+ * Creates a ConnectorChannelClient that calls ConnectorNode methods directly
+ * instead of making HTTP requests.
+ *
+ * Used for embedded mode where the ConnectorNode runs in-process.
+ * The returned client conforms to the ConnectorChannelClient interface,
+ * making it a drop-in replacement for the HTTP-based channel client.
+ *
+ * @param connector - A ConnectorNode instance (or any object matching ConnectorChannelLike)
+ * @returns A ConnectorChannelClient that manages channels via direct function calls
+ *
+ * @example
+ * ```typescript
+ * import { ConnectorNode } from '@toon-protocol/connector';
+ * import { createDirectChannelClient } from '@toon-protocol/core/bootstrap';
+ *
+ * const connector = new ConnectorNode({ ... });
+ * const channelClient = createDirectChannelClient(connector);
+ *
+ * const result = await channelClient.openChannel({
+ *   peerId: 'nostr-54dad746e52dab00',
+ *   chain: 'evm:base:84532',
+ *   peerAddress: '0x6AFbC4...',
+ * });
+ * ```
+ */
+declare function createDirectChannelClient(connector: ConnectorChannelLike): ConnectorChannelClient;
+
+/**
+ * HTTP-based client for connector admin operations.
+ *
+ * Calls the connector's Admin API over HTTP to register/remove peers.
+ */
+
+/**
+ * Creates a ConnectorAdminClient that calls the Connector Admin API via HTTP.
+ *
+ * @param adminUrl - Base URL of the connector admin API (e.g., "http://connector:8081")
+ * @param btpSecret - Shared secret for BTP authentication
+ * @returns A ConnectorAdminClient that manages peers via HTTP
+ *
+ * @example
+ * ```typescript
+ * const adminClient = createHttpConnectorAdmin('http://localhost:8091', 'secret');
+ *
+ * await adminClient.addPeer({
+ *   id: 'peer2',
+ *   url: 'ws://connector-peer2:3000',
+ *   authToken: JSON.stringify({ peerId: 'peer2', secret: 'secret' }),
+ *   routes: [{ prefix: 'g.toon.peer2', priority: 0 }],
+ *   settlement: {
+ *     preference: 'evm',
+ *     evmAddress: '0x...',
+ *     chainId: 31337,
+ *   },
+ * });
+ * ```
+ */
+declare function createHttpConnectorAdmin(adminUrl: string, btpSecret: string): ConnectorAdminClient;
+
+/**
+ * HTTP-based client for sending ILP packets via the connector API.
+ *
+ * Calls the connector's packet handling endpoint over HTTP.
+ */
+
+/**
+ * Creates an IlpClient that sends ILP packets via HTTP.
+ *
+ * @param connectorUrl - Base URL of the connector (e.g., "http://connector:8080")
+ * @returns An IlpClient instance
+ *
+ * @example
+ * ```typescript
+ * const ilpClient = createHttpIlpClient('http://localhost:8081');
+ *
+ * const result = await ilpClient.sendIlpPacket({
+ *   destination: 'g.toon.peer2',
+ *   amount: '1000',
+ *   data: base64EncodedToon,
+ * });
+ * ```
+ */
+declare function createHttpIlpClient(connectorUrl: string): IlpClient;
+
+/**
+ * HTTP-based client for payment channel operations.
+ *
+ * Calls the connector's Admin API to open channels and query channel state.
+ */
+
+/**
+ * Creates a ConnectorChannelClient that calls the Connector Admin API via HTTP.
+ *
+ * @param adminUrl - Base URL of the connector admin API (e.g., "http://connector:8081")
+ * @returns A ConnectorChannelClient that manages channels via HTTP
+ *
+ * @example
+ * ```typescript
+ * const channelClient = createHttpChannelClient('http://localhost:8091');
+ *
+ * const result = await channelClient.openChannel({
+ *   peerId: 'peer2',
+ *   chain: 'evm:base:31337',
+ *   peerAddress: '0x90F79bf6EB2c4f870365E785982E1f101E93b906',
+ *   initialDeposit: '100000',
+ * });
+ * ```
+ */
+declare function createHttpChannelClient(adminUrl: string): ConnectorChannelClient;
+
+/**
+ * AttestationVerifier -- TEE attestation verification, state lifecycle,
+ * and attestation-aware peer ranking for Story 4.3.
+ *
+ * This is a pure logic class with no transport layer. It receives parsed
+ * attestation data and returns verification results. The transport layer
+ * (subscribing to kind:10033 events on relays) is a Story 4.6 concern.
+ *
+ * The AttestationVerifier is the single source of truth for attestation
+ * state (R-E4-008). Both the kind:10033 Nostr event path and the /health
+ * HTTP endpoint derive their TEE state from the same verifier instance.
+ *
+ * Attestation State Machine (Decision 12):
+ *   VALID (within validitySeconds)
+ *     -> STALE (within graceSeconds after validity expires)
+ *       -> UNATTESTED (after grace period expires)
+ *
+ * Trust degrades; money doesn't -- attestation state changes never
+ * trigger payment channel closure.
+ */
+
+/**
+ * Attestation lifecycle state.
+ *
+ * Transitions: VALID -> STALE -> UNATTESTED.
+ * A peer that was never attested starts as UNATTESTED.
+ */
+declare enum AttestationState {
+    /** Attestation is within validity period. */
+    VALID = "valid",
+    /** Attestation has expired but is within the grace period. */
+    STALE = "stale",
+    /** Attestation has expired past the grace period or was never attested. */
+    UNATTESTED = "unattested"
+}
+/** Result of PCR verification against a known-good registry. */
+interface VerificationResult {
+    valid: boolean;
+    reason?: string;
+}
+/**
+ * Descriptor for a peer in the attestation-aware ranking system.
+ * Used by `rankPeers()` to order peers by attestation status.
+ */
+interface PeerDescriptor {
+    pubkey: string;
+    relayUrl: string;
+    attested: boolean;
+    attestationTimestamp?: number;
+}
+/**
+ * Configuration for the AttestationVerifier.
+ */
+interface AttestationVerifierConfig {
+    /** Map of known-good PCR values. Key is PCR hash, value is trust status. */
+    knownGoodPcrs: Map<string, boolean>;
+    /** Attestation validity period in seconds (default: 300). */
+    validitySeconds?: number;
+    /** Grace period in seconds after validity expires before marking as unattested (default: 30). */
+    graceSeconds?: number;
+}
+/**
+ * Verifies TEE attestations, computes attestation lifecycle state,
+ * and ranks peers by attestation status.
+ *
+ * Single source of truth for attestation state (R-E4-008).
+ */
+declare class AttestationVerifier {
+    private readonly knownGoodPcrs;
+    private readonly validitySeconds;
+    private readonly graceSeconds;
+    constructor(config: AttestationVerifierConfig);
+    /**
+     * Verifies a TEE attestation's PCR values against the known-good registry.
+     *
+     * All three PCR values (pcr0, pcr1, pcr2) must be present and truthy in
+     * the registry for verification to pass.
+     *
+     * @param attestation - The TEE attestation to verify.
+     * @returns Verification result with `valid: true` or `valid: false` with reason.
+     */
+    verify(attestation: TeeAttestation): VerificationResult;
+    /**
+     * Computes the attestation lifecycle state based on timing.
+     *
+     * Boundary behavior:
+     * - At exactly `attestedAt + validitySeconds`: VALID (inclusive <=)
+     * - At exactly `attestedAt + validitySeconds + graceSeconds`: STALE (inclusive <=)
+     * - After grace expires: UNATTESTED
+     *
+     * @param _attestation - The TEE attestation (unused, reserved for future per-attestation logic).
+     * @param attestedAt - Unix timestamp when the attestation was created.
+     * @param now - Optional current unix timestamp (defaults to real clock).
+     * @returns The current attestation state.
+     */
+    getAttestationState(_attestation: TeeAttestation, attestedAt: number, now?: number): AttestationState;
+    /**
+     * Ranks peers by attestation status: attested peers first, then non-attested.
+     *
+     * Preserves relative order within each group (stable sort via filter).
+     * Does NOT mutate the input array -- returns a new sorted array.
+     *
+     * Attestation is a preference, not a requirement. Non-attested peers
+     * remain in the result and are connectable.
+     *
+     * @param peers - Array of peer descriptors to rank.
+     * @returns New array with attested peers first, preserving relative order.
+     */
+    rankPeers(peers: PeerDescriptor[]): PeerDescriptor[];
+}
+
+/**
+ * AttestationBootstrap -- attestation-first seed relay bootstrap for Story 4.6.
+ *
+ * Implements FR-TEE-6: the bootstrap trust flow that verifies kind:10033 TEE
+ * attestation on each seed relay BEFORE trusting its kind:10032 peer list.
+ * This prevents seed relay list poisoning (R-E4-004).
+ *
+ * Trust flow:
+ *   1. Read seed relay list from kind:10036 (Story 3.4)
+ *   2. Connect to seed relay
+ *   3. Query kind:10033 attestation
+ *   4. Verify PCR measurement (Story 4.3)
+ *   5. If valid -> subscribe to kind:10032 -> discover peers
+ *   6. If invalid -> fall back to next seed relay
+ *
+ * This is a pure orchestration class with no transport logic. The
+ * `queryAttestation` and `subscribePeers` callbacks are injected via DI,
+ * keeping the class fully testable without WebSocket mocks.
+ *
+ * Decision 12 invariant: "Trust degrades; money doesn't." This class
+ * never touches payment channel state.
+ */
+
+/**
+ * Configuration for the attestation-first bootstrap flow.
+ */
+interface AttestationBootstrapConfig {
+    /** Seed relay WebSocket URLs from kind:10036 */
+    seedRelays: string[];
+    /**
+     * Nostr secret key for signing (reserved for future use).
+     * @remarks Stored in config but not accessed by bootstrap(). Maintained for
+     * API consistency with BootstrapService and future subscription signing.
+     */
+    secretKey: Uint8Array;
+    /**
+     * Verifier instance (or mock) with verify method.
+     *
+     * The DI interface accepts NostrEvent (the raw attestation event) and
+     * returns boolean | Promise<boolean> | VerificationResult to support
+     * both the real verifier (after caller extracts TeeAttestation) and
+     * test mocks (which return Promise<boolean> via mockResolvedValue).
+     *
+     * The implementation normalizes via: await Promise.resolve(verifier.verify(event))
+     */
+    verifier: {
+        verify: (attestation: NostrEvent) => boolean | VerificationResult | Promise<boolean | VerificationResult>;
+        getState?: (...args: unknown[]) => unknown;
+    };
+    /** DI callback: query a relay for its kind:10033 attestation event */
+    queryAttestation: (relayUrl: string) => Promise<NostrEvent | null>;
+    /** DI callback: subscribe to a relay's kind:10032 peer info events */
+    subscribePeers: (relayUrl: string) => Promise<NostrEvent[]>;
+}
+/**
+ * Result of the attestation-first bootstrap flow.
+ */
+interface AttestationBootstrapResult {
+    /** 'attested' if at least one seed relay passed verification, 'degraded' otherwise */
+    mode: 'attested' | 'degraded';
+    /** URL of the first seed relay that passed attestation (undefined in degraded mode) */
+    attestedSeedRelay?: string;
+    /** Peer info events discovered from attested seed relays */
+    discoveredPeers: NostrEvent[];
+}
+/**
+ * Lifecycle events emitted during attestation-first bootstrap.
+ */
+type AttestationBootstrapEvent = {
+    type: 'attestation:seed-connected';
+    relayUrl: string;
+} | {
+    type: 'attestation:verified';
+    relayUrl: string;
+    pubkey: string;
+} | {
+    type: 'attestation:verification-failed';
+    relayUrl: string;
+    reason: string;
+} | {
+    type: 'attestation:peers-discovered';
+    relayUrl: string;
+    peerCount: number;
+} | {
+    type: 'attestation:degraded';
+    triedCount: number;
+};
+/** Listener callback for attestation bootstrap events. */
+type AttestationBootstrapEventListener = (event: AttestationBootstrapEvent) => void;
+/**
+ * Orchestrates attestation-first seed relay bootstrap.
+ *
+ * Iterates seed relays sequentially, verifying kind:10033 attestation
+ * before subscribing to kind:10032 peer info events. Falls back to
+ * degraded mode when all seed relays fail attestation verification.
+ */
+declare class AttestationBootstrap {
+    private readonly config;
+    private listeners;
+    constructor(config: AttestationBootstrapConfig);
+    /**
+     * Register an event listener.
+     */
+    on(listener: AttestationBootstrapEventListener): void;
+    /**
+     * Unregister an event listener.
+     */
+    off(listener: AttestationBootstrapEventListener): void;
+    /**
+     * Emit an attestation bootstrap event to all listeners.
+     */
+    private emit;
+    /**
+     * Execute the attestation-first bootstrap flow.
+     *
+     * Iterates seed relays in order:
+     * 1. Emit seed-connected, query attestation
+     * 2. If null or verify fails or error: emit verification-failed, try next
+     * 3. If valid: emit verified, subscribe peers, emit peers-discovered
+     * 4. Return attested result with discovered peers
+     * 5. If ALL fail: log warning, emit degraded, return degraded result
+     */
+    bootstrap(): Promise<AttestationBootstrapResult>;
+}
+
+/**
+ * TOON Node composition API.
+ *
+ * Provides createToonNode() — a single composition function that wires
+ * ConnectorNode ↔ BLS ↔ BootstrapService ↔ DiscoveryTracker into one object
+ * with start() / stop() lifecycle, enabling zero-latency embedded mode without
+ * manually wiring each component.
+ */
+
+/**
+ * Structural type for incoming ILP packet handler request.
+ *
+ * Matches the shape of BLS HandlePacketRequest without creating a cross-package
+ * dependency from @toon-protocol/core → @toon-protocol/bls.
+ */
+interface HandlePacketRequest {
+    /** Payment amount as string (parsed to bigint) */
+    amount: string;
+    /** ILP destination address */
+    destination: string;
+    /** Base64-encoded TOON Nostr event */
+    data: string;
+    /** Source ILP address */
+    sourceAccount?: string;
+}
+/**
+ * Structural type for ILP packet handler accept response.
+ */
+interface HandlePacketAcceptResponse {
+    accept: true;
+    /** Base64-encoded fulfillment (SHA-256 of event.id) */
+    fulfillment: string;
+    /** Base64-encoded response data (e.g., TOON-encoded response for relay back in ILP FULFILL) */
+    data?: string;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Structural type for ILP packet handler reject response.
+ */
+interface HandlePacketRejectResponse {
+    accept: false;
+    /** ILP error code (F00, F06, T00) */
+    code: string;
+    /** Human-readable error message */
+    message: string;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Union type for ILP packet handler response.
+ */
+type HandlePacketResponse = HandlePacketAcceptResponse | HandlePacketRejectResponse;
+/**
+ * Callback invoked by the connector for incoming ILP packets.
+ *
+ * **NOTE:** This is a **function** (not a BusinessLogicServer instance) because
+ * packet handling logic lives in the caller's entrypoint code, not in
+ * BusinessLogicServer. The caller provides the full handler that knows how to
+ * process incoming events.
+ */
+type PacketHandler = (request: HandlePacketRequest) => HandlePacketResponse | Promise<HandlePacketResponse>;
+/**
+ * Structural interface for the full embedded connector API.
+ *
+ * Combines:
+ * 1. ConnectorNodeLike (sendPacket) — for outbound ILP packets
+ * 2. ConnectorAdminLike (registerPeer, removePeer) — for peer management
+ * 3. setPacketHandler(handler) — for registering the incoming packet callback
+ *
+ * This structural interface allows @toon-protocol/connector's ConnectorNode to
+ * be passed directly without importing it as a dependency.
+ */
+interface EmbeddableConnectorLike {
+    /** Send an outbound ILP packet */
+    sendPacket(params: SendPacketParams): Promise<SendPacketResult>;
+    /** Register a peer with the connector */
+    registerPeer(params: RegisterPeerParams): Promise<void>;
+    /** Remove a peer from the connector */
+    removePeer(peerId: string): Promise<void>;
+    /**
+     * Register the incoming packet handler callback.
+     * The connector invokes this handler for each incoming ILP packet.
+     * Optional in HTTP mode where packets are delivered via local delivery HTTP endpoint.
+     */
+    setPacketHandler?(handler: (request: HandlePacketRequest) => HandlePacketResponse | Promise<HandlePacketResponse>): void;
+    /**
+     * Open a payment channel via the connector's settlement layer.
+     * Optional — only available on ConnectorNode >=1.2.0.
+     */
+    openChannel?(params: {
+        peerId: string;
+        chain: string;
+        token?: string;
+        tokenNetwork?: string;
+        peerAddress: string;
+        initialDeposit?: string;
+        settlementTimeout?: number;
+    }): Promise<{
+        channelId: string;
+        status: string;
+    }>;
+    /**
+     * Get the state of a payment channel.
+     * Optional — only available on ConnectorNode >=1.2.0.
+     */
+    getChannelState?(channelId: string): Promise<{
+        channelId: string;
+        status: 'opening' | 'open' | 'closed' | 'settled';
+        chain: string;
+    }>;
+}
+/**
+ * Configuration for creating an TOON Node.
+ */
+interface ToonNodeConfig {
+    /** The ConnectorNode instance (embeddable connector) */
+    connector: EmbeddableConnectorLike;
+    /**
+     * Callback for incoming ILP packets.
+     *
+     * **NOTE:** Provided as a **function** (not a BLS instance) because packet
+     * handling logic lives in the caller's entrypoint code.
+     */
+    handlePacket: PacketHandler;
+    /** Nostr secret key (32 bytes) */
+    secretKey: Uint8Array;
+    /** Own ILP peer info (ilpAddress, btpEndpoint, assetCode, assetScale) */
+    ilpInfo: IlpPeerInfo;
+    /**
+     * TOON encoder — **required** for encoding Nostr events to binary.
+     * Used by BootstrapService.
+     */
+    toonEncoder: (event: NostrEvent) => Uint8Array;
+    /**
+     * TOON decoder — **required** for decoding binary to Nostr events.
+     * Used by BootstrapService and DirectRuntimeClient.
+     */
+    toonDecoder: (bytes: Uint8Array) => NostrEvent;
+    /** Relay WebSocket URL for monitoring (default: 'ws://localhost:7100') */
+    relayUrl?: string;
+    /** Initial bootstrap peers (default: []) */
+    knownPeers?: KnownPeer[];
+    /** Optional settlement preferences for peer registration */
+    settlementInfo?: SettlementConfig;
+    /** Base price per byte for ILP packet pricing (default: 10n) */
+    basePricePerByte?: bigint;
+    /** Enable ArDrive peer lookup (default: true) */
+    ardriveEnabled?: boolean;
+    /** Default relay URL for ArDrive-sourced peers that lack relay URLs (default: '') */
+    defaultRelayUrl?: string;
+    /** Timeout for relay queries in milliseconds (default: 5000) */
+    queryTimeout?: number;
+    /** Optional extra peers JSON for bootstrap */
+    additionalPeersJson?: string;
+}
+/**
+ * Result returned by ToonNode.start().
+ */
+interface ToonNodeStartResult {
+    /** Results from the bootstrap phase */
+    bootstrapResults: BootstrapResult[];
+    /** Number of peers successfully bootstrapped */
+    peerCount: number;
+    /** Number of payment channels opened */
+    channelCount: number;
+}
+/**
+ * TOON Node instance with lifecycle methods.
+ */
+interface ToonNode {
+    /**
+     * Wire components and run bootstrap.
+     * Throws BootstrapError if already started or on bootstrap failure.
+     */
+    start(): Promise<ToonNodeStartResult>;
+    /**
+     * Tear down and clean up.
+     * Safe to call when not started (no-op).
+     */
+    stop(): Promise<void>;
+    /**
+     * Read-only access to the bootstrap service.
+     * Allows attaching event listeners before calling start().
+     */
+    readonly bootstrapService: BootstrapService;
+    /**
+     * Read-only access to the discovery tracker.
+     * Allows attaching event listeners before calling start().
+     */
+    readonly discoveryTracker: DiscoveryTracker;
+    /**
+     * Channel client for payment channel operations.
+     * Null if the connector does not expose openChannel()/getChannelState().
+     * Available when using @toon-protocol/connector >=1.2.0.
+     */
+    readonly channelClient: ConnectorChannelClient | null;
+    /**
+     * Read-only access to the ILP client for sending packets.
+     * Used by ServiceNode.publishEvent() to send outbound events.
+     */
+    readonly ilpClient: IlpClient;
+    /**
+     * Initiate peering with a discovered peer.
+     * The peer must have been discovered by the discovery tracker first.
+     * Registers the peer with the connector and attempts settlement.
+     */
+    peerWith(pubkey: string): Promise<void>;
+}
+/**
+ * Create a TOON Node with integrated bootstrap and discovery tracking.
+ *
+ * This composition function wires ConnectorNode ↔ DirectRuntimeClient ↔
+ * DirectConnectorAdmin ↔ BootstrapService ↔ DiscoveryTracker into a single
+ * object with start() / stop() lifecycle, enabling zero-latency embedded mode
+ * without manually wiring each component.
+ *
+ * @param config - Configuration for the node
+ * @returns ToonNode instance with start() / stop() methods
+ *
+ * @example
+ * ```typescript
+ * import { ConnectorNode } from '@toon-protocol/connector';
+ * import { createToonNode } from '@toon-protocol/core/compose';
+ * import { encodeEvent, decodeEvent } from '@toon-protocol/relay';
+ *
+ * const connector = new ConnectorNode({ ... });
+ *
+ * const node = createToonNode({
+ *   connector,
+ *   handlePacket: async (req) => { ... },
+ *   secretKey: new Uint8Array(32),
+ *   ilpInfo: { ilpAddress: 'g.example', ... },
+ *   toonEncoder: encodeEvent,
+ *   toonDecoder: decodeEvent,
+ * });
+ *
+ * // Attach event listeners before start
+ * node.bootstrapService.on((event) => console.log('bootstrap:', event));
+ * node.discoveryTracker.on((event) => console.log('discovery:', event));
+ *
+ * // Start the node
+ * const result = await node.start();
+ * console.log(`Bootstrapped ${result.peerCount} peers`);
+ *
+ * // Clean up
+ * await node.stop();
+ * ```
+ */
+declare function createToonNode(config: ToonNodeConfig): ToonNode;
+
+/**
+ * Mock USDC token configuration for local development (Anvil).
+ *
+ * In production, USDC is the native Circle USD Coin on Arbitrum One:
+ *   0xaf88d065e77c8cC2239327C5EDb3A432268e5831
+ *
+ * For local development on Anvil, a mock ERC-20 is deployed at a
+ * deterministic address by the DeployLocal.s.sol script in the connector
+ * repo. This contract serves as the mock USDC for payment channel testing.
+ *
+ * **On-chain decimal discrepancy (Anvil only):**
+ * The legacy on-chain mock contract on Anvil uses 18 decimals (inherited
+ * from the original ERC-20 deploy script in the connector repo). The
+ * constants below reflect production USDC semantics (6 decimals). When
+ * interacting with the Anvil mock contract directly (e.g., fund-peer-wallet.sh,
+ * faucet), use 18 decimals for on-chain amounts. The pricing pipeline
+ * (basePricePerByte * toonLength) is denomination-agnostic (bigint math)
+ * and works correctly regardless of on-chain decimals.
+ *
+ * **FiatTokenV2_2-compatible mock (Epic 5 prep):**
+ * For DVM compute settlement and x402 testing with proper 6-decimal
+ * semantics and EIP-3009 `transferWithAuthorization` support, deploy
+ * the FiatTokenV2_2-compatible mock:
+ *   `./scripts/deploy-mock-usdc.sh`
+ * This deploys a contract with 6 decimals, EIP-3009, and EIP-712
+ * domain matching production USDC ("USD Coin", version "2").
+ *
+ * USDC uses 6 decimals (not 18 like most ERC-20 tokens):
+ *   1 USDC = 1,000,000 micro-USDC (10^6)
+ *
+ * @module
+ */
+/**
+ * Mock USDC contract address on Anvil (deterministic from deployment).
+ *
+ * This is the first contract deployed by DeployLocal.s.sol using
+ * Anvil Account #0 at nonce 0, giving it a deterministic address.
+ */
+declare const MOCK_USDC_ADDRESS: "0x5FbDB2315678afecb367f032d93F642f64180aa3";
+/**
+ * USDC uses 6 decimals (1 USDC = 1,000,000 micro-units).
+ *
+ * This differs from most ERC-20 tokens which use 18 decimals.
+ * All pricing amounts in the TOON protocol are denominated
+ * in USDC micro-units when using USDC as the settlement token.
+ */
+declare const USDC_DECIMALS: 6;
+/** USDC token symbol. */
+declare const USDC_SYMBOL: "USDC";
+/** USDC token name. */
+declare const USDC_NAME: "USD Coin";
+/**
+ * Configuration for the mock USDC contract deployment.
+ */
+interface MockUsdcConfig {
+    /** Contract address on the target chain */
+    address: string;
+    /** Number of decimal places (6 for USDC) */
+    decimals: number;
+    /** Token symbol */
+    symbol: string;
+    /** Token name */
+    name: string;
+}
+/**
+ * Default mock USDC configuration for Anvil local development.
+ */
+declare const MOCK_USDC_CONFIG: MockUsdcConfig;
+
+/**
+ * Multi-environment chain configuration for TOON relay nodes.
+ *
+ * Provides chain presets for three deployment environments:
+ * - **anvil** (local dev): Deterministic Anvil addresses, localhost RPC
+ * - **arbitrum-sepolia** (staging): Circle testnet USDC on Arbitrum Sepolia
+ * - **arbitrum-one** (production): Native USDC on Arbitrum One
+ *
+ * Environment variable overrides:
+ * - `TOON_CHAIN` overrides the config-level chain parameter
+ * - `TOON_RPC_URL` overrides the preset RPC endpoint
+ * - `TOON_TOKEN_NETWORK` overrides the preset TokenNetwork address
+ *
+ * @module
+ */
+/**
+ * Supported chain preset names.
+ */
+type ChainName = 'anvil' | 'arbitrum-sepolia' | 'arbitrum-one';
+/**
+ * Resolved chain configuration with all fields populated.
+ */
+interface ChainPreset {
+    /** Preset identifier ('anvil' | 'arbitrum-sepolia' | 'arbitrum-one'). */
+    name: string;
+    /** EVM chain ID. */
+    chainId: number;
+    /** Default RPC endpoint URL. */
+    rpcUrl: string;
+    /** USDC token contract address on this chain. */
+    usdcAddress: string;
+    /** TokenNetwork contract address for USDC on this chain. */
+    tokenNetworkAddress: string;
+}
+/**
+ * Built-in chain presets for supported deployment environments.
+ *
+ * Each preset provides the chainId, RPC URL, USDC address, and
+ * TokenNetwork address for its environment. Fields can be overridden
+ * at runtime via environment variables.
+ */
+declare const CHAIN_PRESETS: Record<ChainName, ChainPreset>;
+/**
+ * Resolve chain configuration from a chain name, with environment
+ * variable overrides applied.
+ *
+ * Resolution order:
+ * 1. `TOON_CHAIN` env var overrides the `chain` parameter
+ * 2. Defaults to `'anvil'` if neither is provided
+ * 3. Looks up the chain name in `CHAIN_PRESETS`
+ * 4. `TOON_RPC_URL` env var overrides the preset's `rpcUrl`
+ * 5. `TOON_TOKEN_NETWORK` env var overrides the preset's `tokenNetworkAddress`
+ *
+ * Returns a defensive copy -- callers can mutate the result without
+ * affecting the shared preset objects.
+ *
+ * @param chain - Chain name to resolve (default: 'anvil')
+ * @returns Resolved chain preset with env var overrides applied
+ * @throws ToonError if the chain name is not recognized
+ */
+declare function resolveChainConfig(chain?: ChainName | string): ChainPreset;
+/**
+ * Build an EIP-712 domain separator from a resolved chain configuration.
+ *
+ * The returned domain matches the structure used by
+ * `getBalanceProofDomain()` in `packages/client/src/signing/evm-signer.ts`:
+ *
+ * ```typescript
+ * { name: 'TokenNetwork', version: '1', chainId, verifyingContract }
+ * ```
+ *
+ * Since `@toon-protocol/core` does not depend on viem, the `verifyingContract`
+ * field is typed as `string` (not viem's `Hex`). Consumers in the client
+ * package can cast to `Hex` if needed.
+ *
+ * @param config - Resolved chain preset
+ * @returns EIP-712 domain separator object
+ */
+declare function buildEip712Domain(config: ChainPreset): {
+    name: string;
+    version: string;
+    chainId: number;
+    verifyingContract: string;
+};
+
+/**
+ * Shared ILP PREPARE packet construction for the TOON protocol.
+ *
+ * This function is the **single point of truth** for constructing ILP PREPARE
+ * packet parameters. Both the x402 `/publish` handler and the existing
+ * `publishEvent()` in the SDK must use it (or produce equivalent output).
+ *
+ * This ensures packet equivalence: the destination relay cannot distinguish
+ * between packets sent via the x402 HTTP on-ramp and the ILP-native rail.
+ *
+ * @module
+ */
+/**
+ * Parameters for constructing an ILP PREPARE packet.
+ */
+interface BuildIlpPrepareParams {
+    /** ILP destination address (e.g., "g.toon.target-relay"). */
+    destination: string;
+    /** Payment amount in ILP units (bigint). */
+    amount: bigint;
+    /** TOON-encoded event as raw bytes. */
+    data: Uint8Array;
+    /** Packet expiry. Default: 30 seconds from now. */
+    expiresAt?: Date;
+}
+/**
+ * Result of building an ILP PREPARE packet.
+ *
+ * This matches the shape expected by `IlpClient.sendIlpPacket()`:
+ * `{ destination, amount, data }` where amount is a string and data
+ * is base64-encoded.
+ */
+interface IlpPreparePacket {
+    /** ILP destination address. */
+    destination: string;
+    /** Payment amount as a string (BigInt.toString()). */
+    amount: string;
+    /** TOON-encoded event as base64 string. */
+    data: string;
+}
+/**
+ * Build an ILP PREPARE packet from the given parameters.
+ *
+ * Converts the bigint amount to a string, encodes the TOON data to base64,
+ * and passes through the destination. This is deliberately simple -- the
+ * value is in having ONE function both the x402 and ILP paths call, not
+ * in complex logic.
+ *
+ * @param params - Packet construction parameters.
+ * @returns ILP PREPARE packet fields ready for `sendIlpPacket()`.
+ */
+declare function buildIlpPrepare(params: BuildIlpPrepareParams): IlpPreparePacket;
+
+/**
+ * KMS identity derivation for TEE enclave-bound keypairs.
+ *
+ * Derives a Nostr-compatible secp256k1 keypair from a raw 32-byte Nautilus
+ * KMS seed using the NIP-06 derivation path (m/44'/1237'/0'/0/{index}).
+ *
+ * The KMS seed is only accessible when the enclave's attestation is valid
+ * (correct PCR values). If the relay code changes, PCR values change,
+ * attestation fails, KMS seed becomes inaccessible, and the relay loses its
+ * identity -- creating a cryptographic binding: identity proves code integrity.
+ *
+ * This module lives in @toon-protocol/core (not SDK) because Docker entrypoints
+ * import from core. It does NOT include EVM address derivation (SDK concern).
+ */
+
+/**
+ * Error thrown when KMS identity derivation fails.
+ * Signals that the enclave cannot derive its identity -- this is a
+ * security-critical condition that must NEVER fall back to random keys.
+ */
+declare class KmsIdentityError extends ToonError {
+    constructor(message: string, cause?: Error);
+}
+/** A Nostr keypair derived from a KMS seed. */
+interface KmsKeypair {
+    /** The 32-byte secp256k1 secret key derived from the KMS seed. */
+    secretKey: Uint8Array;
+    /** The x-only Schnorr public key (32 bytes, 64 lowercase hex characters). */
+    pubkey: string;
+}
+/** Options for `deriveFromKmsSeed()`. */
+interface DeriveFromKmsSeedOptions {
+    /** BIP-39 mnemonic -- when provided, takes precedence over raw seed for derivation. */
+    mnemonic?: string;
+    /** Key index in the NIP-06 derivation path. Defaults to 0. */
+    accountIndex?: number;
+}
+/**
+ * Derives a Nostr keypair from a raw 32-byte KMS seed or BIP-39 mnemonic
+ * using the NIP-06 derivation path.
+ *
+ * When `options.mnemonic` is provided it takes precedence over the raw seed.
+ * The raw seed is still validated even when a mnemonic is supplied (caller
+ * must always provide a valid seed to prove KMS reachability).
+ *
+ * @param seed - A 32-byte Uint8Array from Nautilus KMS.
+ * @param options - Optional derivation overrides (mnemonic, accountIndex).
+ * @returns A `KmsKeypair` with `secretKey` and `pubkey`.
+ * @throws {KmsIdentityError} If the seed is invalid or derivation fails.
+ */
+declare function deriveFromKmsSeed(seed: Uint8Array, options?: DeriveFromKmsSeedOptions): KmsKeypair;
+
+/**
+ * Nix Build Orchestration for Reproducible Docker Images
+ *
+ * The NixBuilder class wraps the `nix build` CLI invocation to produce
+ * deterministic Docker images for TEE (Trusted Execution Environment)
+ * deployment. Each build returns a NixBuildResult containing the image
+ * hash, PCR (Platform Configuration Register) values, and Nix store path.
+ *
+ * PCR values are SHA-384 hashes measured by the TEE hardware from the
+ * loaded image. If the Docker image is deterministic (identical content
+ * hash across builds), then PCR values will also be identical -- enabling
+ * remote attestation verification (Story 4.3 AttestationVerifier).
+ *
+ * IMPORTANT: The NixBuilder shells out to `nix build` -- it requires
+ * the Nix package manager to be installed on the build machine. Tests
+ * that exercise actual Nix builds should be conditionally skipped when
+ * Nix is not available. Unit tests use mocked child_process.
+ *
+ * @module
+ */
+/**
+ * Result of a Nix build invocation.
+ * Contains the Docker image content hash, PCR values derived from the image,
+ * the Nix store path, and the build timestamp.
+ */
+interface NixBuildResult {
+    /** Docker image content hash (sha256:... -- 64 lowercase hex chars after prefix) */
+    imageHash: string;
+    /** PCR0 -- SHA-384 hash of the enclave image (96 lowercase hex chars) */
+    pcr0: string;
+    /** PCR1 -- SHA-384 hash of the kernel (96 lowercase hex chars) */
+    pcr1: string;
+    /** PCR2 -- SHA-384 hash of the application (96 lowercase hex chars) */
+    pcr2: string;
+    /** Path to the image in the Nix store (/nix/store/...) */
+    imagePath: string;
+    /** Unix timestamp (seconds since epoch) of the build */
+    buildTimestamp: number;
+}
+/**
+ * Configuration for the NixBuilder.
+ */
+interface NixBuilderConfig {
+    /** Root directory of the project (containing flake.nix) */
+    projectRoot: string;
+    /** Path to Dockerfile.nix relative to projectRoot */
+    dockerfilePath: string;
+    /**
+     * Optional source overrides for testing. Keys are relative paths from
+     * projectRoot, values are the file content to write. When set, NixBuilder
+     * creates a temporary copy of the source tree with the overrides applied
+     * before running the build. This allows testing that source changes
+     * produce different PCR values.
+     */
+    sourceOverride?: Record<string, string>;
+}
+/**
+ * Orchestrates Nix-based Docker image builds for reproducible TEE deployment.
+ *
+ * The build() method shells out to `nix build .#docker-image` and parses the
+ * output to extract the image hash, Nix store path, and PCR values. PCR values
+ * are computed from the image content using SHA-384 to simulate the measurement
+ * that would be performed by the TEE hardware (AWS Nitro hypervisor).
+ *
+ * @example
+ * ```typescript
+ * const builder = new NixBuilder({
+ *   projectRoot: '/path/to/toon',
+ *   dockerfilePath: 'docker/Dockerfile.nix',
+ * });
+ * const result = await builder.build();
+ * console.log(result.imageHash);  // sha256:abc123...
+ * console.log(result.pcr0);       // 96-char hex string
+ * ```
+ */
+declare class NixBuilder {
+    private readonly config;
+    constructor(config: NixBuilderConfig);
+    /**
+     * Execute a Nix build and return the result.
+     *
+     * Shells out to `nix build .#docker-image` in the project root directory.
+     * If sourceOverride is configured, creates a temporary modified source tree.
+     *
+     * @throws Error if Nix is not installed or the build fails
+     */
+    build(): Promise<NixBuildResult>;
+}
+
+/**
+ * PCR Validation and Dockerfile Determinism Analysis
+ *
+ * Provides utilities for verifying PCR (Platform Configuration Register)
+ * reproducibility across independent Nix builds, and for statically
+ * analyzing Dockerfile.nix expressions for non-deterministic patterns.
+ *
+ * PCR values are SHA-384 hashes (96 lowercase hex characters) measured
+ * by the TEE hardware. If two builds of the same source tree produce
+ * different PCR values, the attestation verification model collapses
+ * (R-E4-002, Score 6) because the AttestationVerifier cannot compare
+ * observed PCR values against a known-good registry.
+ *
+ * @module
+ */
+
+/**
+ * A forbidden pattern that must not appear in a deterministic Dockerfile/Nix
+ * expression. Each entry includes a regex, a human-readable name, and an
+ * explanation of why the pattern breaks reproducibility.
+ */
+interface ForbiddenPattern {
+    /** Regex to match against each line of the Dockerfile */
+    pattern: RegExp;
+    /** Human-readable name of the pattern (e.g., 'apt-get update') */
+    name: string;
+    /** Explanation of why this pattern breaks reproducibility */
+    reason: string;
+}
+/**
+ * A single violation found during determinism analysis. Includes the line
+ * number (1-indexed), the name of the matched pattern, and the text that
+ * triggered the match.
+ */
+interface Violation {
+    /** Line number (1-indexed) where the violation was found */
+    line: number;
+    /** Name of the forbidden pattern that matched */
+    patternName: string;
+    /** The text from the line that triggered the match */
+    matchedText: string;
+}
+/**
+ * Result of analyzing a Dockerfile for non-deterministic patterns.
+ */
+interface DeterminismReport {
+    /** True if no forbidden patterns were found */
+    deterministic: boolean;
+    /** List of violations found (empty if deterministic) */
+    violations: Violation[];
+    /** Number of lines scanned */
+    scannedLines: number;
+}
+/**
+ * Result of comparing two NixBuildResults for PCR reproducibility.
+ */
+interface PcrReproducibilityResult {
+    /** True if all PCR values and image hash match */
+    reproducible: boolean;
+    /** Whether PCR0 values match */
+    pcr0Match: boolean;
+    /** Whether PCR1 values match */
+    pcr1Match: boolean;
+    /** Whether PCR2 values match */
+    pcr2Match: boolean;
+    /** Whether Docker image content hashes match */
+    imageHashMatch: boolean;
+    /** The actual PCR and hash values from both builds for debugging */
+    details: {
+        buildA: {
+            pcr0: string;
+            pcr1: string;
+            pcr2: string;
+            imageHash: string;
+        };
+        buildB: {
+            pcr0: string;
+            pcr1: string;
+            pcr2: string;
+            imageHash: string;
+        };
+    };
+    /** Human-readable summary suitable for CI log output */
+    summary: string;
+}
+/**
+ * Options for verifyPcrReproducibility().
+ */
+interface VerifyOptions {
+    /** If true, throws PcrReproducibilityError when builds diverge */
+    throwOnMismatch?: boolean;
+}
+/**
+ * Error thrown when PCR reproducibility verification fails (builds diverge).
+ * Contains both build results in the error message for CI debugging.
+ */
+declare class PcrReproducibilityError extends ToonError {
+    constructor(buildA: NixBuildResult, buildB: NixBuildResult);
+}
+/**
+ * Reads the content of a Dockerfile.nix file from disk.
+ *
+ * This is a thin I/O wrapper separated from the analysis function to keep
+ * `analyzeDockerfileForNonDeterminism()` a pure function (no side effects).
+ *
+ * @param filePath - Absolute path to the Dockerfile.nix file
+ * @returns The file content as a UTF-8 string
+ */
+declare function readDockerfileNix(filePath: string): Promise<string>;
+/**
+ * Analyzes a Dockerfile/Nix expression for non-deterministic patterns.
+ *
+ * This is a pure function -- it takes the file content as a string and an
+ * array of forbidden patterns, and returns a structured report. No I/O is
+ * performed; file reading is handled by `readDockerfileNix()`.
+ *
+ * Each line of the content is tested against every forbidden pattern. Lines
+ * that start with '#' (comments) are skipped since they don't affect the
+ * build output.
+ *
+ * @param content - The Dockerfile/Nix expression content as a string
+ * @param forbiddenPatterns - Array of patterns that indicate non-determinism
+ * @returns A DeterminismReport with violations and line numbers
+ *
+ * @example
+ * ```typescript
+ * const report = analyzeDockerfileForNonDeterminism(content, [
+ *   { pattern: /apt-get\s+update/, name: 'apt-get update', reason: '...' },
+ * ]);
+ * if (!report.deterministic) {
+ *   console.error('Violations:', report.violations);
+ * }
+ * ```
+ */
+declare function analyzeDockerfileForNonDeterminism(content: string, forbiddenPatterns: ForbiddenPattern[]): DeterminismReport;
+/**
+ * Verifies that two NixBuildResults are reproducible -- i.e., they produce
+ * identical PCR values and Docker image content hashes.
+ *
+ * This function is intended for CI pipelines: build the Docker image twice
+ * from the same source tree, then call this function to verify the outputs
+ * match. If they don't, the build is non-deterministic and PCR-based
+ * attestation verification will fail.
+ *
+ * PCR values are normalized to lowercase before comparison to avoid
+ * case-sensitivity issues.
+ *
+ * @param buildA - Result from the first build
+ * @param buildB - Result from the second build
+ * @param options - Optional: throwOnMismatch to throw PcrReproducibilityError
+ * @returns A structured PcrReproducibilityResult with match details and summary
+ *
+ * Note: This function is async by API contract (Story 4.5 AC #4) to allow
+ * future implementations to perform I/O (e.g., fetching PCR values from a
+ * remote registry). The current implementation is synchronous.
+ *
+ * @example
+ * ```typescript
+ * const buildA = await builder.build();
+ * const buildB = await builder.build();
+ * const result = await verifyPcrReproducibility(buildA, buildB, {
+ *   throwOnMismatch: true,
+ * });
+ * console.log(result.summary); // "PCR reproducibility: PASS ..."
+ * ```
+ */
+declare function verifyPcrReproducibility(buildA: NixBuildResult, buildB: NixBuildResult, options?: VerifyOptions): Promise<PcrReproducibilityResult>;
+
+/**
+ * Structured logging for the TOON protocol.
+ *
+ * Provides JSON-formatted log output with contextual fields for:
+ * - TEE enclave observability (component, enclaveType)
+ * - DVM job log correlation (correlationId)
+ * - Multi-node debugging (nodeId, pubkey)
+ *
+ * Zero runtime dependencies. Uses console.log/console.error as the
+ * transport layer. Output is structured JSON when `json: true` (default
+ * in production), or human-readable when `json: false` (development).
+ *
+ * @module
+ */
+/**
+ * Log levels ordered by severity.
+ */
+type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+/**
+ * Configuration for creating a Logger instance.
+ */
+interface LoggerConfig {
+    /** Component name (e.g., 'bootstrap', 'x402', 'attestation') */
+    component: string;
+    /** Minimum log level to emit. Default: 'info' */
+    level?: LogLevel;
+    /** Output as JSON. Default: true */
+    json?: boolean;
+    /** Static context fields merged into every log entry */
+    context?: Record<string, unknown>;
+}
+/**
+ * A structured log entry.
+ */
+interface LogEntry {
+    /** ISO 8601 timestamp */
+    timestamp: string;
+    /** Log level */
+    level: LogLevel;
+    /** Component that produced the log */
+    component: string;
+    /** Log message */
+    msg: string;
+    /** Additional structured fields */
+    [key: string]: unknown;
+}
+/**
+ * Structured logger with contextual fields.
+ *
+ * Usage:
+ * ```typescript
+ * const log = createLogger({ component: 'bootstrap' });
+ * log.info('Peer registered', { peerId: 'abc', ilpAddress: 'g.toon.peer' });
+ * log.error('Bootstrap failed', { error: err.message });
+ *
+ * // Child logger with additional context
+ * const jobLog = log.child({ correlationId: 'job-123' });
+ * jobLog.info('DVM job started');
+ * ```
+ */
+interface Logger {
+    debug(msg: string, fields?: Record<string, unknown>): void;
+    info(msg: string, fields?: Record<string, unknown>): void;
+    warn(msg: string, fields?: Record<string, unknown>): void;
+    error(msg: string, fields?: Record<string, unknown>): void;
+    /**
+     * Create a child logger with additional context fields.
+     * The child inherits all parent context and adds its own.
+     */
+    child(context: Record<string, unknown>): Logger;
+}
+/**
+ * Create a structured logger.
+ *
+ * @param config - Logger configuration
+ * @returns A Logger instance
+ */
+declare function createLogger(config: LoggerConfig): Logger;
+
+/**
+ * @toon-protocol/core
+ *
+ * Core library for Nostr-based ILP peer discovery.
+ */
+declare const VERSION = "0.1.0";
+
+export { type AgentRuntimeClient, ArDrivePeerRegistry, AttestationBootstrap, type AttestationBootstrapConfig, type AttestationBootstrapEvent, type AttestationBootstrapEventListener, type AttestationBootstrapResult, type AttestationEventOptions, AttestationState, AttestationVerifier, type AttestationVerifierConfig, type BootstrapConfig, BootstrapError, type BootstrapEvent, type BootstrapEventListener, type BootstrapPhase, type BootstrapResult, BootstrapService, type BootstrapServiceConfig, type BuildIlpPrepareParams, CHAIN_PRESETS, type ChainName, type ChainPreset, type ChannelState, type ConnectorAdminClient, type ConnectorAdminLike, type ConnectorChannelClient, type ConnectorChannelLike, type ConnectorNodeLike, type DeriveFromKmsSeedOptions, type DeterminismReport, type DirectRuntimeClientConfig, type DiscoveredPeer, type DiscoveryTracker, type DiscoveryTrackerConfig, type DvmJobStatus, type EmbeddableConnectorLike, type ForbiddenPattern, type GenesisPeer, GenesisPeerLoader, type HandlePacketAcceptResponse, type HandlePacketRejectResponse, type HandlePacketRequest, type HandlePacketResponse, ILP_PEER_INFO_KIND, IMAGE_GENERATION_KIND, type IlpClient, type IlpPeerInfo, type IlpPreparePacket, type IlpSendResult, JOB_FEEDBACK_KIND, JOB_REQUEST_KIND_BASE, JOB_RESULT_KIND_BASE, type JobFeedbackParams, type JobRequestParams, type JobResultParams, KmsIdentityError, type KmsKeypair, type KnownPeer, type LogEntry, type LogLevel, type Logger, type LoggerConfig, MOCK_USDC_ADDRESS, MOCK_USDC_CONFIG, type MockUsdcConfig, type NixBuildResult, NixBuilder, type NixBuilderConfig, NostrPeerDiscovery, type OpenChannelParams, type OpenChannelResult, type PacketHandler, type ParsedAttestation, type ParsedJobFeedback, type ParsedJobRequest, type ParsedJobResult, PcrReproducibilityError, type PcrReproducibilityResult, type PeerDescriptor, type PublishSeedRelayConfig, type RegisterPeerParams, SEED_RELAY_LIST_KIND, SERVICE_DISCOVERY_KIND, SeedRelayDiscovery, type SeedRelayDiscoveryConfig, type SeedRelayDiscoveryResult, type SeedRelayEntry, type SendPacketParams, type SendPacketResult, type ServiceDiscoveryContent, type SettlementConfig, type SkillDescriptor, type SocialDiscoveryEvent, type SocialDiscoveryEventListener, SocialPeerDiscovery, type SocialPeerDiscoveryConfig, type Subscription, TEE_ATTESTATION_KIND, TEXT_GENERATION_KIND, TEXT_TO_SPEECH_KIND, TRANSLATION_KIND, type TeeAttestation, ToonError, type ToonNode, type ToonNodeConfig, type ToonNodeStartResult, USDC_DECIMALS, USDC_NAME, USDC_SYMBOL, VERSION, type VerificationResult, type VerifyOptions, type Violation, analyzeDockerfileForNonDeterminism, buildAttestationEvent, buildEip712Domain, buildIlpPeerInfoEvent, buildIlpPrepare, buildJobFeedbackEvent, buildJobRequestEvent, buildJobResultEvent, buildSeedRelayListEvent, buildServiceDiscoveryEvent, createAgentRuntimeClient, createDirectChannelClient, createDirectConnectorAdmin, createDirectIlpClient, createDirectRuntimeClient, createDiscoveryTracker, createHttpChannelClient, createHttpConnectorAdmin, createHttpIlpClient$1 as createHttpIlpClient, createHttpRuntimeClient, createHttpIlpClient as createHttpRuntimeClientV2, createLogger, createToonNode, deriveFromKmsSeed, negotiateSettlementChain, parseAttestation, parseIlpPeerInfo, parseJobFeedback, parseJobRequest, parseJobResult, parseSeedRelayList, parseServiceDiscovery, publishSeedRelayEntry, readDockerfileNix, resolveChainConfig, resolveTokenForChain, validateChainId, verifyPcrReproducibility };