@toon-protocol/sdk 0.1.4

package/dist/index.js

@@ -0,0 +1,945 @@
+// src/identity.ts
+import {
+  generateMnemonic as _generateMnemonic,
+  validateMnemonic,
+  mnemonicToSeedSync
+} from "@scure/bip39";
+import { wordlist } from "@scure/bip39/wordlists/english.js";
+import { HDKey } from "@scure/bip32";
+import { getPublicKey } from "nostr-tools/pure";
+import { secp256k1 } from "@noble/curves/secp256k1.js";
+import { keccak_256 } from "@noble/hashes/sha3.js";
+import { bytesToHex } from "@noble/hashes/utils.js";
+
+// src/errors.ts
+import { ToonError } from "@toon-protocol/core";
+var IdentityError = class extends ToonError {
+  constructor(message, cause) {
+    super(message, "IDENTITY_ERROR", cause);
+    this.name = "IdentityError";
+  }
+};
+var NodeError = class extends ToonError {
+  constructor(message, cause) {
+    super(message, "NODE_ERROR", cause);
+    this.name = "NodeError";
+  }
+};
+var HandlerError = class extends ToonError {
+  constructor(message, cause) {
+    super(message, "HANDLER_ERROR", cause);
+    this.name = "HandlerError";
+  }
+};
+var VerificationError = class extends ToonError {
+  constructor(message, cause) {
+    super(message, "VERIFICATION_ERROR", cause);
+    this.name = "VerificationError";
+  }
+};
+var PricingError = class extends ToonError {
+  constructor(message, cause) {
+    super(message, "PRICING_ERROR", cause);
+    this.name = "PricingError";
+  }
+};
+
+// src/identity.ts
+function generateMnemonic() {
+  return _generateMnemonic(wordlist, 128);
+}
+function fromMnemonic(mnemonic, options) {
+  if (!validateMnemonic(mnemonic, wordlist)) {
+    throw new IdentityError(
+      `Invalid BIP-39 mnemonic: the provided words do not form a valid mnemonic phrase`
+    );
+  }
+  const accountIndex = options?.accountIndex ?? 0;
+  if (!Number.isInteger(accountIndex) || accountIndex < 0 || accountIndex > MAX_BIP32_INDEX) {
+    throw new IdentityError(
+      `Invalid accountIndex: expected a non-negative integer (0 to ${MAX_BIP32_INDEX}), got ${String(accountIndex)}`
+    );
+  }
+  const path = `m/44'/1237'/0'/0/${accountIndex}`;
+  let seed;
+  try {
+    seed = mnemonicToSeedSync(mnemonic);
+    const hdKey = HDKey.fromMasterSeed(seed).derive(path);
+    if (!hdKey.privateKey) {
+      throw new IdentityError(`Failed to derive private key at path ${path}`);
+    }
+    const secretKey = hdKey.privateKey;
+    return deriveIdentity(secretKey);
+  } catch (error) {
+    if (error instanceof IdentityError) {
+      throw error;
+    }
+    throw new IdentityError(
+      `Key derivation failed at path ${path}: ${error instanceof Error ? error.message : String(error)}`,
+      error instanceof Error ? error : void 0
+    );
+  } finally {
+    if (seed) {
+      seed.fill(0);
+    }
+  }
+}
+function fromSecretKey(secretKey) {
+  if (!(secretKey instanceof Uint8Array)) {
+    throw new IdentityError(
+      `Invalid secret key: expected Uint8Array, got ${secretKey === null ? "null" : typeof secretKey}`
+    );
+  }
+  if (secretKey.length !== 32) {
+    throw new IdentityError(
+      `Invalid secret key: expected 32 bytes, got ${secretKey.length} bytes`
+    );
+  }
+  try {
+    return deriveIdentity(secretKey);
+  } catch (error) {
+    if (error instanceof IdentityError) {
+      throw error;
+    }
+    throw new IdentityError(
+      `Invalid secret key: ${error instanceof Error ? error.message : String(error)}`,
+      error instanceof Error ? error : void 0
+    );
+  }
+}
+var MAX_BIP32_INDEX = 2147483647;
+function deriveIdentity(secretKey) {
+  const pubkey = getPublicKey(secretKey);
+  const evmAddress = computeEvmAddress(secretKey);
+  return { secretKey: new Uint8Array(secretKey), pubkey, evmAddress };
+}
+function computeEvmAddress(secretKey) {
+  const uncompressedPubkey = secp256k1.getPublicKey(secretKey, false);
+  const pubkeyWithoutPrefix = uncompressedPubkey.slice(1);
+  const hash = keccak_256(pubkeyWithoutPrefix);
+  const addressBytes = hash.slice(-20);
+  const addressHex = bytesToHex(addressBytes);
+  return toChecksumAddress(addressHex);
+}
+function toChecksumAddress(addressHex) {
+  const lower = addressHex.toLowerCase();
+  const hash = bytesToHex(keccak_256(new TextEncoder().encode(lower)));
+  let checksummed = "0x";
+  for (let i = 0; i < 40; i++) {
+    const char = lower[i];
+    const hashChar = hash[i];
+    if (char === void 0 || hashChar === void 0) {
+      throw new IdentityError(
+        `Unexpected undefined at index ${i} during checksum computation`
+      );
+    }
+    const hashNibble = parseInt(hashChar, 16);
+    checksummed += hashNibble >= 8 ? char.toUpperCase() : char;
+  }
+  return checksummed;
+}
+
+// src/handler-context.ts
+function createHandlerContext(options) {
+  let cachedEvent;
+  return {
+    get toon() {
+      return options.toon;
+    },
+    get kind() {
+      return options.meta.kind;
+    },
+    get pubkey() {
+      return options.meta.pubkey;
+    },
+    get amount() {
+      return options.amount;
+    },
+    get destination() {
+      return options.destination;
+    },
+    decode() {
+      if (!cachedEvent) {
+        cachedEvent = options.toonDecoder(options.toon);
+      }
+      return cachedEvent;
+    },
+    accept(metadata) {
+      return {
+        accept: true,
+        fulfillment: "default-fulfillment",
+        ...metadata ? { metadata } : {}
+      };
+    },
+    reject(code, message) {
+      return {
+        accept: false,
+        code,
+        message
+      };
+    }
+  };
+}
+
+// src/handler-registry.ts
+import { JOB_REQUEST_KIND_BASE } from "@toon-protocol/core";
+var HandlerRegistry = class {
+  handlers = /* @__PURE__ */ new Map();
+  defaultHandler;
+  /**
+   * Register a handler for a specific event kind.
+   * Replaces any existing handler for that kind.
+   */
+  on(kind, handler) {
+    this.handlers.set(kind, handler);
+    return this;
+  }
+  /**
+   * Register a default handler for unrecognized kinds.
+   */
+  onDefault(handler) {
+    this.defaultHandler = handler;
+    return this;
+  }
+  /**
+   * Returns all registered kind numbers, sorted ascending.
+   */
+  getRegisteredKinds() {
+    return [...this.handlers.keys()].sort((a, b) => a - b);
+  }
+  /**
+   * Returns registered kinds in the DVM request range (5000-5999), sorted ascending.
+   * Uses JOB_REQUEST_KIND_BASE (5000) as the range start.
+   */
+  getDvmKinds() {
+    const dvmRangeStart = JOB_REQUEST_KIND_BASE;
+    const dvmRangeEnd = JOB_REQUEST_KIND_BASE + 999;
+    return this.getRegisteredKinds().filter(
+      (k) => k >= dvmRangeStart && k <= dvmRangeEnd
+    );
+  }
+  /**
+   * Dispatch a context to the appropriate handler based on kind.
+   */
+  async dispatch(ctx) {
+    const handler = this.handlers.get(ctx.kind);
+    if (handler) {
+      return handler(ctx);
+    }
+    if (this.defaultHandler) {
+      return this.defaultHandler(ctx);
+    }
+    return {
+      accept: false,
+      code: "F00",
+      message: `No handler registered for kind ${ctx.kind}`
+    };
+  }
+};
+
+// src/pricing-validator.ts
+function createPricingValidator(config) {
+  const basePricePerByte = config.basePricePerByte ?? 10n;
+  return {
+    validate(meta, amount) {
+      if (meta.pubkey === config.ownPubkey) {
+        return { accepted: true };
+      }
+      const kindOverride = config.kindPricing && Object.hasOwn(config.kindPricing, meta.kind) ? config.kindPricing[meta.kind] : void 0;
+      const pricePerByte = kindOverride ?? basePricePerByte;
+      const requiredAmount = BigInt(meta.rawBytes.length) * pricePerByte;
+      if (amount < requiredAmount) {
+        return {
+          accepted: false,
+          rejection: {
+            accept: false,
+            code: "F04",
+            message: "Insufficient payment",
+            metadata: {
+              required: requiredAmount.toString(),
+              received: amount.toString()
+            }
+          }
+        };
+      }
+      return { accepted: true };
+    }
+  };
+}
+
+// src/verification-pipeline.ts
+import { schnorr } from "@noble/curves/secp256k1.js";
+import { hexToBytes } from "@noble/hashes/utils.js";
+function createVerificationPipeline(config) {
+  return {
+    async verify(meta, _toonData) {
+      if (config.devMode) {
+        return { verified: true };
+      }
+      try {
+        const sigBytes = hexToBytes(meta.sig);
+        const msgBytes = hexToBytes(meta.id);
+        const pubkeyBytes = hexToBytes(meta.pubkey);
+        const valid = schnorr.verify(sigBytes, msgBytes, pubkeyBytes);
+        if (!valid) {
+          return {
+            verified: false,
+            rejection: {
+              accept: false,
+              code: "F06",
+              message: "Invalid Schnorr signature"
+            }
+          };
+        }
+        return { verified: true };
+      } catch {
+        return {
+          verified: false,
+          rejection: {
+            accept: false,
+            code: "F06",
+            message: "Signature verification failed"
+          }
+        };
+      }
+    }
+  };
+}
+
+// src/payment-handler-bridge.ts
+function createPaymentHandlerBridge(config) {
+  const { registry } = config;
+  return {
+    async handlePayment(request) {
+      let amount;
+      try {
+        amount = BigInt(request.amount);
+      } catch {
+        return {
+          accept: false,
+          code: "T00",
+          message: "Invalid payment amount"
+        };
+      }
+      const ctx = createHandlerContext({
+        toon: request.data,
+        meta: {
+          kind: 0,
+          pubkey: "",
+          id: "",
+          sig: "",
+          rawBytes: new Uint8Array(0)
+        },
+        amount,
+        destination: request.destination,
+        toonDecoder: () => {
+          throw new Error("decode not available in bridge");
+        }
+      });
+      if (request.isTransit) {
+        void registry.dispatch(ctx).catch((err) => {
+          const errMsg = err instanceof Error ? err.message : "Unknown error";
+          console.error("Transit handler error:", errMsg);
+        });
+        return { accept: true };
+      }
+      try {
+        return await registry.dispatch(ctx);
+      } catch (err) {
+        const errMsg = err instanceof Error ? err.message : "Unknown error";
+        console.error("Handler error:", errMsg);
+        return {
+          accept: false,
+          code: "T00",
+          message: "Internal error"
+        };
+      }
+    }
+  };
+}
+
+// src/event-storage-handler.ts
+function createEventStorageHandler(_config) {
+  throw new Error(
+    "createEventStorageHandler is not yet implemented in @toon-protocol/sdk. Use @toon-protocol/town for the relay implementation."
+  );
+}
+
+// src/create-node.ts
+import { createServer } from "http";
+import {
+  createToonNode,
+  BootstrapService,
+  createDiscoveryTracker,
+  createHttpIlpClient,
+  createHttpConnectorAdmin,
+  createHttpChannelClient,
+  resolveChainConfig,
+  buildIlpPrepare,
+  buildJobFeedbackEvent,
+  buildJobResultEvent,
+  parseJobResult
+} from "@toon-protocol/core";
+import {
+  shallowParseToon,
+  decodeEventFromToon,
+  encodeEventToToon
+} from "@toon-protocol/core/toon";
+
+// src/skill-descriptor.ts
+function buildSkillDescriptor(registry, config = {}) {
+  const dvmKinds = registry.getDvmKinds();
+  if (dvmKinds.length === 0) {
+    return void 0;
+  }
+  const basePricePerByte = config.basePricePerByte ?? 10n;
+  const kindPricing = config.kindPricing ?? {};
+  const pricing = {};
+  for (const kind of dvmKinds) {
+    if (Object.hasOwn(kindPricing, kind)) {
+      pricing[String(kind)] = String(kindPricing[kind]);
+    } else {
+      pricing[String(kind)] = String(basePricePerByte);
+    }
+  }
+  const descriptor = {
+    name: config.name ?? "toon-dvm",
+    version: config.version ?? "1.0",
+    kinds: dvmKinds,
+    features: config.features ?? [],
+    inputSchema: config.inputSchema ?? { type: "object", properties: {} },
+    pricing
+  };
+  if (config.models !== void 0) {
+    descriptor.models = config.models;
+  }
+  return descriptor;
+}
+
+// src/create-node.ts
+var MAX_PAYLOAD_BASE64_LENGTH = 1048576;
+function createNode(config) {
+  const hasConnector = config.connector !== void 0;
+  const hasConnectorUrl = config.connectorUrl !== void 0;
+  if (hasConnector && hasConnectorUrl) {
+    throw new NodeError(
+      "NodeConfig: provide either connector or connectorUrl, not both"
+    );
+  }
+  if (!hasConnector && !hasConnectorUrl) {
+    throw new NodeError(
+      "NodeConfig: one of connector or connectorUrl is required"
+    );
+  }
+  if (hasConnectorUrl && config.handlerPort === void 0) {
+    throw new NodeError(
+      "NodeConfig: handlerPort is required when using connectorUrl (standalone mode)"
+    );
+  }
+  const embeddedMode = hasConnector;
+  const chainConfig = resolveChainConfig(config.chain);
+  let effectiveSettlementInfo = config.settlementInfo;
+  if (!effectiveSettlementInfo) {
+    const chainKey = `evm:base:${chainConfig.chainId}`;
+    const supportedChains = [chainKey];
+    const preferredTokens = {
+      [chainKey]: chainConfig.usdcAddress
+    };
+    const tokenNetworks = chainConfig.tokenNetworkAddress ? { [chainKey]: chainConfig.tokenNetworkAddress } : void 0;
+    effectiveSettlementInfo = {
+      supportedChains,
+      preferredTokens,
+      ...tokenNetworks && { tokenNetworks }
+    };
+  }
+  let identity;
+  try {
+    identity = fromSecretKey(config.secretKey);
+  } catch (error) {
+    throw new NodeError(
+      `Invalid secretKey: ${error instanceof Error ? error.message : String(error)}`,
+      error instanceof Error ? error : void 0
+    );
+  }
+  const { pubkey, evmAddress } = identity;
+  const registry = new HandlerRegistry();
+  if (config.handlers) {
+    for (const [kind, handler] of Object.entries(config.handlers)) {
+      const kindNum = Number(kind);
+      if (!Number.isInteger(kindNum) || kindNum < 0) {
+        throw new NodeError(
+          `Invalid event kind in handlers config: expected a non-negative integer, got '${kind}'`
+        );
+      }
+      registry.on(kindNum, handler);
+    }
+  }
+  if (config.defaultHandler) {
+    registry.onDefault(config.defaultHandler);
+  }
+  const verifier = createVerificationPipeline({
+    devMode: config.devMode ?? false
+  });
+  const pricer = createPricingValidator({
+    basePricePerByte: config.basePricePerByte ?? 10n,
+    ownPubkey: pubkey,
+    kindPricing: config.kindPricing
+  });
+  const encoder = config.toonEncoder ?? encodeEventToToon;
+  const decoder = config.toonDecoder ?? decodeEventFromToon;
+  const contextDecoder = (toon) => {
+    const bytes = Buffer.from(toon, "base64");
+    return decoder(bytes);
+  };
+  const trackerRef = {};
+  const pipelinedHandler = async (request) => {
+    if (request.data.length > MAX_PAYLOAD_BASE64_LENGTH) {
+      return {
+        accept: false,
+        code: "F06",
+        message: `Payload too large: ${request.data.length} bytes exceeds maximum ${MAX_PAYLOAD_BASE64_LENGTH}`
+      };
+    }
+    const toonBytes = Buffer.from(request.data, "base64");
+    let meta;
+    try {
+      meta = shallowParseToon(toonBytes);
+    } catch {
+      return {
+        accept: false,
+        code: "F06",
+        message: "Invalid TOON payload: failed to parse routing metadata"
+      };
+    }
+    if (config.devMode ?? false) {
+      const toonPreview = request.data.length > 80 ? request.data.substring(0, 80) + "..." : request.data;
+      const sanitize = (s) => s.replace(/[\x00-\x1f\x7f]/g, "");
+      console.log(
+        "[toon:dev]",
+        `kind=${meta.kind}`,
+        `pubkey=${meta.pubkey.substring(0, 16)}...`,
+        `amount=${sanitize(request.amount)}`,
+        `dest=${sanitize(request.destination)}`,
+        `toon=${toonPreview}`
+      );
+    }
+    const verifyResult = await verifier.verify(meta, request.data);
+    if (!verifyResult.verified) {
+      if (verifyResult.rejection) {
+        return verifyResult.rejection;
+      }
+      return { accept: false, code: "F06", message: "Verification failed" };
+    }
+    let amount;
+    try {
+      amount = BigInt(request.amount);
+    } catch {
+      if (config.devMode ?? false) {
+        amount = 0n;
+      } else {
+        return {
+          accept: false,
+          code: "T00",
+          message: "Invalid payment amount"
+        };
+      }
+    }
+    if (!(config.devMode ?? false)) {
+      const priceResult = pricer.validate(meta, amount);
+      if (!priceResult.accepted) {
+        if (priceResult.rejection) {
+          return priceResult.rejection;
+        }
+        return {
+          accept: false,
+          code: "F04",
+          message: "Pricing validation failed"
+        };
+      }
+    }
+    const ctx = createHandlerContext({
+      toon: request.data,
+      meta,
+      amount,
+      destination: request.destination,
+      toonDecoder: contextDecoder
+    });
+    try {
+      const result = await registry.dispatch(ctx);
+      if (result.accept && meta.kind === 10032 && trackerRef.current) {
+        const decoded = ctx.decode();
+        if (decoded) {
+          trackerRef.current.processEvent(decoded);
+        }
+      }
+      return result;
+    } catch (err) {
+      const errMsg = err instanceof Error ? err.message : "Unknown error";
+      console.error("Handler dispatch failed:", errMsg);
+      return { accept: false, code: "T00", message: "Internal error" };
+    }
+  };
+  const ilpInfo = {
+    ilpAddress: config.ilpAddress ?? "g.toon.local",
+    btpEndpoint: config.btpEndpoint ?? "",
+    assetCode: config.assetCode ?? "USD",
+    assetScale: config.assetScale ?? 6
+  };
+  let ilpClient;
+  let adminClient;
+  let channelClient = null;
+  let bootstrapServiceInstance;
+  let discoveryTrackerInstance;
+  let httpServer = null;
+  let doStart;
+  let doStop;
+  if (embeddedMode) {
+    const toonNode = createToonNode({
+      connector: config.connector,
+      handlePacket: pipelinedHandler,
+      secretKey: config.secretKey,
+      ilpInfo,
+      toonEncoder: encoder,
+      toonDecoder: decoder,
+      relayUrl: config.relayUrl,
+      knownPeers: config.knownPeers,
+      settlementInfo: effectiveSettlementInfo,
+      basePricePerByte: config.basePricePerByte,
+      ardriveEnabled: config.ardriveEnabled
+    });
+    ilpClient = toonNode.ilpClient;
+    channelClient = toonNode.channelClient;
+    bootstrapServiceInstance = toonNode.bootstrapService;
+    discoveryTrackerInstance = toonNode.discoveryTracker;
+    adminClient = {
+      addPeer: () => Promise.resolve(),
+      removePeer: () => Promise.resolve()
+    };
+    trackerRef.current = discoveryTrackerInstance;
+    doStart = async () => toonNode.start();
+    doStop = async () => toonNode.stop();
+  } else {
+    const connectorUrl = config.connectorUrl;
+    const handlerPort = config.handlerPort;
+    ilpClient = createHttpIlpClient(connectorUrl);
+    adminClient = createHttpConnectorAdmin(connectorUrl, "");
+    if (effectiveSettlementInfo) {
+      channelClient = createHttpChannelClient(connectorUrl);
+    }
+    bootstrapServiceInstance = new BootstrapService(
+      {
+        knownPeers: config.knownPeers ?? [],
+        ardriveEnabled: config.ardriveEnabled ?? false,
+        defaultRelayUrl: config.relayUrl ?? "",
+        settlementInfo: effectiveSettlementInfo,
+        ownIlpAddress: ilpInfo.ilpAddress,
+        toonEncoder: encoder,
+        toonDecoder: decoder,
+        basePricePerByte: config.basePricePerByte ?? 10n
+      },
+      config.secretKey,
+      ilpInfo
+    );
+    bootstrapServiceInstance.setIlpClient(ilpClient);
+    bootstrapServiceInstance.setConnectorAdmin(adminClient);
+    if (channelClient) {
+      bootstrapServiceInstance.setChannelClient(channelClient);
+    }
+    discoveryTrackerInstance = createDiscoveryTracker({
+      secretKey: config.secretKey,
+      settlementInfo: effectiveSettlementInfo
+    });
+    discoveryTrackerInstance.setConnectorAdmin(adminClient);
+    if (channelClient) {
+      discoveryTrackerInstance.setChannelClient(channelClient);
+    }
+    trackerRef.current = discoveryTrackerInstance;
+    doStart = async () => {
+      httpServer = createServer(async (req, res) => {
+        if (req.method === "GET" && req.url === "/health") {
+          res.writeHead(200, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ status: "healthy", pubkey }));
+          return;
+        }
+        if (req.method === "POST" && req.url === "/handle-packet") {
+          let body = "";
+          req.on("data", (chunk) => {
+            body += chunk.toString();
+          });
+          req.on("end", async () => {
+            try {
+              const request = JSON.parse(body);
+              if (request.amount === void 0 || request.amount === null || request.destination === void 0 || request.destination === null || request.data === void 0 || request.data === null) {
+                res.writeHead(400, { "Content-Type": "application/json" });
+                res.end(
+                  JSON.stringify({
+                    accept: false,
+                    code: "F00",
+                    message: "Missing required fields"
+                  })
+                );
+                return;
+              }
+              const result = await pipelinedHandler(request);
+              res.writeHead(result.accept ? 200 : 400, {
+                "Content-Type": "application/json"
+              });
+              res.end(JSON.stringify(result));
+            } catch (err) {
+              console.error("[SDK] handle-packet error:", err);
+              res.writeHead(500, { "Content-Type": "application/json" });
+              res.end(
+                JSON.stringify({
+                  accept: false,
+                  code: "T00",
+                  message: "Internal server error"
+                })
+              );
+            }
+          });
+          return;
+        }
+        res.writeHead(404);
+        res.end();
+      });
+      await new Promise((resolve) => {
+        httpServer?.listen(handlerPort, () => resolve());
+      });
+      const results = await bootstrapServiceInstance.bootstrap();
+      const bootstrapPeerPubkeys = results.map((r) => r.knownPeer.pubkey);
+      discoveryTrackerInstance.addExcludedPubkeys(bootstrapPeerPubkeys);
+      return {
+        bootstrapResults: results,
+        peerCount: results.length,
+        channelCount: results.filter((r) => r.channelId).length
+      };
+    };
+    doStop = async () => {
+      const server = httpServer;
+      if (server) {
+        await new Promise((resolve) => {
+          server.close(() => resolve());
+        });
+        httpServer = null;
+      }
+    };
+  }
+  let started = false;
+  const node = {
+    get pubkey() {
+      return pubkey;
+    },
+    get evmAddress() {
+      return evmAddress;
+    },
+    get connector() {
+      return config.connector ?? null;
+    },
+    get channelClient() {
+      return channelClient;
+    },
+    getSkillDescriptor() {
+      return buildSkillDescriptor(registry, {
+        basePricePerByte: config.basePricePerByte ?? 10n,
+        kindPricing: config.kindPricing,
+        ...config.skillConfig
+      });
+    },
+    on(kindOrEvent, handlerOrListener) {
+      if (typeof kindOrEvent === "number") {
+        if (!Number.isInteger(kindOrEvent) || kindOrEvent < 0) {
+          throw new NodeError(
+            `Invalid event kind: expected a non-negative integer, got ${String(kindOrEvent)}`
+          );
+        }
+        registry.on(kindOrEvent, handlerOrListener);
+      } else if (kindOrEvent === "bootstrap") {
+        const listener = handlerOrListener;
+        bootstrapServiceInstance.on(listener);
+        discoveryTrackerInstance.on(listener);
+      } else {
+        const sanitized = String(kindOrEvent).replace(/[\x00-\x1f\x7f]/g, "");
+        throw new NodeError(
+          `Unknown lifecycle event: '${sanitized}'. Supported: 'bootstrap'`
+        );
+      }
+      return node;
+    },
+    onDefault(handler) {
+      registry.onDefault(handler);
+      return node;
+    },
+    async start() {
+      if (started) {
+        throw new NodeError("Node already started");
+      }
+      try {
+        const result = await doStart();
+        started = true;
+        return {
+          peerCount: result.peerCount,
+          channelCount: result.channelCount,
+          bootstrapResults: result.bootstrapResults
+        };
+      } catch (error) {
+        if (error instanceof NodeError) {
+          throw error;
+        }
+        throw new NodeError(
+          `Failed to start node: ${error instanceof Error ? error.message : String(error)}`,
+          error instanceof Error ? error : void 0
+        );
+      }
+    },
+    async stop() {
+      if (!started) {
+        return;
+      }
+      await doStop();
+      started = false;
+    },
+    async peerWith(targetPubkey) {
+      if (!started) {
+        throw new NodeError(
+          "Cannot peer: node not started. Call start() first."
+        );
+      }
+      if (typeof targetPubkey !== "string" || targetPubkey.length !== 64 || !/^[0-9a-f]{64}$/.test(targetPubkey)) {
+        throw new NodeError(
+          "Invalid pubkey: expected a 64-character lowercase hex string"
+        );
+      }
+      return discoveryTrackerInstance.peerWith(targetPubkey);
+    },
+    async publishEvent(event, options) {
+      if (!started) {
+        throw new NodeError(
+          "Cannot publish: node not started. Call start() first."
+        );
+      }
+      if (!options?.destination) {
+        throw new NodeError(
+          "Cannot publish: destination is required. Pass { destination: 'g.peer.address' }."
+        );
+      }
+      try {
+        const toonData = encoder(event);
+        const amount = (config.basePricePerByte ?? 10n) * BigInt(toonData.length);
+        const packet = buildIlpPrepare({
+          destination: options.destination,
+          amount,
+          data: toonData
+        });
+        const result = await ilpClient.sendIlpPacket(packet);
+        if (result.accepted) {
+          return {
+            success: true,
+            eventId: event.id,
+            fulfillment: result.fulfillment ?? ""
+          };
+        }
+        return {
+          success: false,
+          eventId: event.id,
+          code: result.code ?? "T00",
+          message: result.message ?? "Unknown error"
+        };
+      } catch (error) {
+        if (error instanceof NodeError) {
+          throw error;
+        }
+        throw new NodeError(
+          `Failed to publish event: ${error instanceof Error ? error.message : String(error)}`,
+          error instanceof Error ? error : void 0
+        );
+      }
+    },
+    async publishFeedback(requestEventId, customerPubkey, status, content, options) {
+      const feedbackEvent = buildJobFeedbackEvent(
+        { requestEventId, customerPubkey, status, content },
+        config.secretKey
+      );
+      return node.publishEvent(feedbackEvent, options);
+    },
+    async publishResult(requestEventId, customerPubkey, amount, content, options) {
+      const resultKind = options?.kind ?? 6100;
+      const resultEvent = buildJobResultEvent(
+        { kind: resultKind, requestEventId, customerPubkey, amount, content },
+        config.secretKey
+      );
+      return node.publishEvent(resultEvent, options);
+    },
+    async settleCompute(resultEvent, providerIlpAddress, options) {
+      if (!started) {
+        throw new NodeError(
+          "Cannot settle compute: node not started. Call start() first."
+        );
+      }
+      if (!providerIlpAddress || typeof providerIlpAddress !== "string" || providerIlpAddress.trim() === "") {
+        throw new NodeError(
+          "Cannot settle compute: providerIlpAddress is required. Resolve it from the provider's kind:10035 service discovery event."
+        );
+      }
+      const parsed = parseJobResult(resultEvent);
+      if (!parsed) {
+        throw new NodeError(
+          "Cannot settle compute: failed to parse result event. Ensure the event is a valid Kind 6xxx with an amount tag."
+        );
+      }
+      const computeAmount = parsed.amount;
+      let amountBigInt;
+      try {
+        amountBigInt = BigInt(computeAmount);
+      } catch {
+        throw new NodeError(
+          `Cannot settle compute: result event amount ('${computeAmount}') is not a valid numeric string.`
+        );
+      }
+      if (amountBigInt < 0n) {
+        throw new NodeError(
+          `Cannot settle compute: result event amount ('${computeAmount}') must be non-negative.`
+        );
+      }
+      if (options?.originalBid !== void 0) {
+        let bidBigInt;
+        try {
+          bidBigInt = BigInt(options.originalBid);
+        } catch {
+          throw new NodeError(
+            `Cannot settle compute: originalBid ('${options.originalBid}') is not a valid numeric string.`
+          );
+        }
+        if (amountBigInt > bidBigInt) {
+          throw new NodeError(
+            `Cannot settle compute: result amount (${computeAmount}) exceeds original bid (${options.originalBid}). Potential provider overcharge.`
+          );
+        }
+      }
+      return ilpClient.sendIlpPacket({
+        destination: providerIlpAddress,
+        amount: computeAmount,
+        data: ""
+      });
+    }
+  };
+  return node;
+}
+export {
+  HandlerError,
+  HandlerRegistry,
+  IdentityError,
+  NodeError,
+  PricingError,
+  VerificationError,
+  buildSkillDescriptor,
+  createEventStorageHandler,
+  createHandlerContext,
+  createNode,
+  createPaymentHandlerBridge,
+  createPricingValidator,
+  createVerificationPipeline,
+  fromMnemonic,
+  fromSecretKey,
+  generateMnemonic
+};
+//# sourceMappingURL=index.js.map