@toon-protocol/core 1.2.0 → 1.4.0

package/dist/index.js

@@ -22,6 +22,260 @@ var TEXT_GENERATION_KIND = 5100;
 var IMAGE_GENERATION_KIND = 5200;
 var TEXT_TO_SPEECH_KIND = 5300;
 var TRANSLATION_KIND = 5302;
+var WORKFLOW_CHAIN_KIND = 10040;
+var JOB_REVIEW_KIND = 31117;
+var WEB_OF_TRUST_KIND = 30382;
+var PREFIX_CLAIM_KIND = 10034;
+var PREFIX_GRANT_KIND = 10037;
+var BLOB_STORAGE_REQUEST_KIND = 5094;
+var BLOB_STORAGE_RESULT_KIND = 6094;
+var PET_INTERACTION_REQUEST_KIND = 5900;
+var PET_INTERACTION_RESULT_KIND = 6900;
+var PET_INTERACTION_EVENT_KIND = 14919;
+var ILP_ROOT_PREFIX = "g.toon";
+
+// src/address/ilp-address-validation.ts
+var ILP_SEGMENT_PATTERN = /^[a-z0-9-]+$/;
+var MAX_ILP_ADDRESS_LENGTH = 1023;
+function isValidIlpAddressStructure(address) {
+  if (!address) return false;
+  if (address.length > MAX_ILP_ADDRESS_LENGTH) return false;
+  const segments = address.split(".");
+  for (const segment of segments) {
+    if (segment.length === 0) return false;
+    if (!ILP_SEGMENT_PATTERN.test(segment)) return false;
+  }
+  return true;
+}
+function validateIlpAddress(address) {
+  if (address.length > MAX_ILP_ADDRESS_LENGTH) {
+    throw new ToonError(
+      `Invalid ILP address: exceeds maximum length of ${MAX_ILP_ADDRESS_LENGTH}`,
+      "ADDRESS_INVALID_PREFIX"
+    );
+  }
+  const segments = address.split(".");
+  for (const segment of segments) {
+    if (segment.length === 0) {
+      throw new ToonError(
+        `Invalid ILP address: empty segment in "${address}"`,
+        "ADDRESS_INVALID_PREFIX"
+      );
+    }
+    if (!ILP_SEGMENT_PATTERN.test(segment)) {
+      throw new ToonError(
+        `Invalid ILP address: segment "${segment}" contains invalid characters`,
+        "ADDRESS_INVALID_PREFIX"
+      );
+    }
+  }
+}
+
+// src/address/derive-child-address.ts
+var HEX_PATTERN = /^[0-9a-fA-F]+$/;
+var PUBKEY_TRUNCATION_LENGTH = 8;
+var MAX_PUBKEY_LENGTH = 128;
+var MAX_ILP_ADDRESS_LENGTH2 = 1023;
+function deriveChildAddress(parentPrefix, childPubkey) {
+  if (!parentPrefix) {
+    throw new ToonError(
+      "Parent prefix must not be empty",
+      "ADDRESS_INVALID_PREFIX"
+    );
+  }
+  validateIlpAddress(parentPrefix);
+  if (childPubkey.length < PUBKEY_TRUNCATION_LENGTH) {
+    throw new ToonError(
+      `Invalid pubkey: must be at least ${PUBKEY_TRUNCATION_LENGTH} hex characters, got ${childPubkey.length}`,
+      "ADDRESS_INVALID_PUBKEY"
+    );
+  }
+  if (childPubkey.length > MAX_PUBKEY_LENGTH) {
+    throw new ToonError(
+      `Invalid pubkey: exceeds maximum length of ${MAX_PUBKEY_LENGTH} characters`,
+      "ADDRESS_INVALID_PUBKEY"
+    );
+  }
+  if (!HEX_PATTERN.test(childPubkey)) {
+    throw new ToonError(
+      `Invalid pubkey: contains non-hex characters`,
+      "ADDRESS_INVALID_PUBKEY"
+    );
+  }
+  const childSegment = childPubkey.slice(0, PUBKEY_TRUNCATION_LENGTH).toLowerCase();
+  const derivedAddress = `${parentPrefix}.${childSegment}`;
+  if (derivedAddress.length > MAX_ILP_ADDRESS_LENGTH2) {
+    throw new ToonError(
+      `Derived ILP address exceeds maximum length of ${MAX_ILP_ADDRESS_LENGTH2}`,
+      "ADDRESS_TOO_LONG"
+    );
+  }
+  return derivedAddress;
+}
+
+// src/address/btp-prefix-exchange.ts
+var MAX_PREFIX_LENGTH = 1023;
+function extractPrefixFromHandshake(handshakeData) {
+  const prefix = handshakeData["prefix"];
+  if (prefix === void 0 || prefix === null || prefix === "") {
+    throw new ToonError(
+      "BTP handshake response missing required prefix field",
+      "ADDRESS_MISSING_PREFIX"
+    );
+  }
+  if (typeof prefix !== "string") {
+    throw new ToonError(
+      "BTP handshake response missing required prefix field",
+      "ADDRESS_MISSING_PREFIX"
+    );
+  }
+  if (prefix.length > MAX_PREFIX_LENGTH) {
+    throw new ToonError(
+      `BTP handshake prefix exceeds maximum length of ${MAX_PREFIX_LENGTH}`,
+      "ADDRESS_INVALID_PREFIX"
+    );
+  }
+  if (!isValidIlpAddressStructure(prefix)) {
+    throw new ToonError(
+      `BTP handshake prefix is not a valid ILP address: "${prefix}"`,
+      "ADDRESS_INVALID_PREFIX"
+    );
+  }
+  return prefix;
+}
+function buildPrefixHandshakeData(ownIlpAddress) {
+  if (ownIlpAddress.length > MAX_PREFIX_LENGTH) {
+    throw new ToonError(
+      `Cannot build handshake data: address exceeds maximum length of ${MAX_PREFIX_LENGTH}`,
+      "ADDRESS_INVALID_PREFIX"
+    );
+  }
+  if (!isValidIlpAddressStructure(ownIlpAddress)) {
+    throw new ToonError(
+      `Cannot build handshake data: "${ownIlpAddress}" is not a valid ILP address`,
+      "ADDRESS_INVALID_PREFIX"
+    );
+  }
+  return { prefix: ownIlpAddress };
+}
+function validatePrefixConsistency(handshakePrefix, advertisedPrefix) {
+  if (advertisedPrefix === void 0) {
+    return;
+  }
+  if (handshakePrefix !== advertisedPrefix) {
+    throw new ToonError(
+      `BTP handshake prefix "${handshakePrefix}" does not match upstream kind:10032 advertised address "${advertisedPrefix}"`,
+      "ADDRESS_PREFIX_MISMATCH"
+    );
+  }
+}
+function checkAddressCollision(derivedAddress, knownPeerAddresses) {
+  if (knownPeerAddresses.includes(derivedAddress)) {
+    throw new ToonError(
+      `Derived ILP address "${derivedAddress}" collides with an existing peer address`,
+      "ADDRESS_COLLISION"
+    );
+  }
+}
+
+// src/address/address-assignment.ts
+function assignAddressFromHandshake(handshakeData, ownPubkey) {
+  const prefix = extractPrefixFromHandshake(handshakeData);
+  return deriveChildAddress(prefix, ownPubkey);
+}
+function isGenesisNode(config) {
+  return config.ilpAddress === ILP_ROOT_PREFIX;
+}
+
+// src/address/address-registry.ts
+var AddressRegistry = class {
+  prefixToAddress = /* @__PURE__ */ new Map();
+  /**
+   * Registers a new upstream prefix -> derived address mapping.
+   *
+   * @param upstreamPrefix - The upstream peer's ILP address prefix
+   * @param derivedAddress - The derived ILP address for this node under that prefix
+   */
+  addAddress(upstreamPrefix, derivedAddress) {
+    this.prefixToAddress.set(upstreamPrefix, derivedAddress);
+  }
+  /**
+   * Removes the mapping for the given upstream prefix.
+   *
+   * @param upstreamPrefix - The upstream prefix to remove
+   * @returns The removed derived address, or `undefined` if the prefix was not found
+   */
+  removeAddress(upstreamPrefix) {
+    const address = this.prefixToAddress.get(upstreamPrefix);
+    if (address !== void 0) {
+      this.prefixToAddress.delete(upstreamPrefix);
+    }
+    return address;
+  }
+  /**
+   * Returns all derived addresses in insertion order.
+   */
+  getAddresses() {
+    return [...this.prefixToAddress.values()];
+  }
+  /**
+   * Returns `true` if the given upstream prefix is registered.
+   */
+  hasPrefix(upstreamPrefix) {
+    return this.prefixToAddress.has(upstreamPrefix);
+  }
+  /**
+   * Returns the number of registered addresses.
+   */
+  get size() {
+    return this.prefixToAddress.size;
+  }
+  /**
+   * Returns the primary (first inserted) address.
+   *
+   * @returns The first address, or `undefined` if the registry is empty
+   */
+  getPrimaryAddress() {
+    const first = this.prefixToAddress.values().next();
+    return first.done ? void 0 : first.value;
+  }
+};
+
+// src/address/prefix-validation.ts
+var RESERVED_WORDS = /* @__PURE__ */ new Set(["toon", "ilp", "local", "peer", "test"]);
+var PREFIX_PATTERN = /^[a-z0-9]+$/;
+var MIN_LENGTH = 2;
+var MAX_LENGTH = 16;
+function validatePrefix(prefix) {
+  if (typeof prefix !== "string" || prefix.length === 0) {
+    return { valid: false, reason: "Prefix must be a non-empty string" };
+  }
+  if (prefix.length < MIN_LENGTH) {
+    return {
+      valid: false,
+      reason: `Prefix must have a minimum of ${MIN_LENGTH} characters, got ${prefix.length}`
+    };
+  }
+  if (prefix.length > MAX_LENGTH) {
+    return {
+      valid: false,
+      reason: `Prefix must have a maximum of ${MAX_LENGTH} characters, got ${prefix.length}`
+    };
+  }
+  if (!PREFIX_PATTERN.test(prefix)) {
+    return {
+      valid: false,
+      reason: "Prefix must contain only lowercase alphanumeric characters [a-z0-9]"
+    };
+  }
+  if (RESERVED_WORDS.has(prefix)) {
+    return {
+      valid: false,
+      reason: `Prefix "${prefix}" is a reserved word`
+    };
+  }
+  return { valid: true };
+}
 
 // src/events/parsers.ts
 function validateChainId(chainId) {
@@ -57,7 +311,8 @@ function parseIlpPeerInfo(event) {
     blsHttpEndpoint,
     settlementEngine,
     assetCode,
-    assetScale
+    assetScale,
+    ilpAddresses: rawIlpAddresses
   } = parsed;
   if (typeof ilpAddress !== "string" || ilpAddress.length === 0) {
     throw new InvalidEventError(
@@ -142,6 +397,52 @@ function parseIlpPeerInfo(event) {
       throw new InvalidEventError("tokenNetworks must be an object");
     }
   }
+  const { feePerByte: rawFeePerByte } = parsed;
+  let feePerByte;
+  if (rawFeePerByte === void 0) {
+    feePerByte = "0";
+  } else if (typeof rawFeePerByte !== "string" || !/^\d+$/.test(rawFeePerByte)) {
+    throw new InvalidEventError(
+      `Invalid feePerByte: "${String(rawFeePerByte)}" must be a non-negative integer string`
+    );
+  } else {
+    feePerByte = rawFeePerByte;
+  }
+  const { prefixPricing: rawPrefixPricing } = parsed;
+  let prefixPricing;
+  if (rawPrefixPricing !== void 0) {
+    if (!isObject(rawPrefixPricing)) {
+      throw new InvalidEventError("prefixPricing must be an object");
+    }
+    const { basePrice } = rawPrefixPricing;
+    if (typeof basePrice !== "string" || !/^\d+$/.test(basePrice)) {
+      throw new InvalidEventError(
+        `Invalid prefixPricing.basePrice: "${String(basePrice)}" must be a non-negative integer string`
+      );
+    }
+    prefixPricing = { basePrice };
+  }
+  let ilpAddresses;
+  if (rawIlpAddresses !== void 0) {
+    if (!Array.isArray(rawIlpAddresses)) {
+      throw new InvalidEventError("ilpAddresses must be an array");
+    }
+    for (const addr of rawIlpAddresses) {
+      if (typeof addr !== "string" || addr.length === 0) {
+        throw new InvalidEventError(
+          "ilpAddresses elements must be non-empty strings"
+        );
+      }
+      if (!isValidIlpAddressStructure(addr)) {
+        throw new InvalidEventError(
+          `Invalid ILP address in ilpAddresses: "${addr}"`
+        );
+      }
+    }
+    ilpAddresses = rawIlpAddresses;
+  } else {
+    ilpAddresses = [ilpAddress];
+  }
   return {
     ilpAddress,
     btpEndpoint,
@@ -156,17 +457,51 @@ function parseIlpPeerInfo(event) {
     },
     ...tokenNetworks !== void 0 && {
       tokenNetworks
-    }
+    },
+    ilpAddresses,
+    feePerByte,
+    ...prefixPricing !== void 0 && { prefixPricing }
   };
 }
 
 // src/events/builders.ts
 import { finalizeEvent } from "nostr-tools/pure";
 function buildIlpPeerInfoEvent(info, secretKey) {
+  if (info.feePerByte !== void 0) {
+    if (typeof info.feePerByte !== "string" || !/^\d+$/.test(info.feePerByte)) {
+      throw new ToonError(
+        `Invalid feePerByte: "${String(info.feePerByte)}" must be a non-negative integer string`,
+        "INVALID_FEE"
+      );
+    }
+  }
+  let effectiveInfo = info;
+  if (info.ilpAddresses !== void 0) {
+    const addresses = info.ilpAddresses;
+    if (addresses.length === 0) {
+      throw new ToonError(
+        "ilpAddresses must be a non-empty array: a node must have at least one address",
+        "ADDRESS_EMPTY_ADDRESSES"
+      );
+    }
+    for (const addr of addresses) {
+      if (!isValidIlpAddressStructure(addr)) {
+        throw new ToonError(
+          `Invalid ILP address in ilpAddresses: "${addr}"`,
+          "ADDRESS_INVALID_PREFIX"
+        );
+      }
+    }
+    const primaryAddress = addresses[0];
+    effectiveInfo = {
+      ...info,
+      ilpAddress: primaryAddress
+    };
+  }
   return finalizeEvent(
     {
       kind: ILP_PEER_INFO_KIND,
-      content: JSON.stringify(info),
+      content: JSON.stringify(effectiveInfo),
       tags: [],
       created_at: Math.floor(Date.now() / 1e3)
     },
@@ -376,6 +711,32 @@ function parseServiceDiscovery(event) {
         return null;
       skillResult.attestation = attestation;
     }
+    const reputation = skillRecord["reputation"];
+    if (reputation !== void 0) {
+      if (typeof reputation !== "object" || reputation === null || Array.isArray(reputation))
+        return null;
+      const repRecord = reputation;
+      const repScore = repRecord["score"];
+      if (typeof repScore !== "number" || !isFinite(repScore)) return null;
+      const signals = repRecord["signals"];
+      if (typeof signals !== "object" || signals === null || Array.isArray(signals))
+        return null;
+      const sigRecord = signals;
+      const trustedBy = sigRecord["trustedBy"];
+      if (typeof trustedBy !== "number" || !isFinite(trustedBy)) return null;
+      const channelVolumeUsdc = sigRecord["channelVolumeUsdc"];
+      if (typeof channelVolumeUsdc !== "number" || !isFinite(channelVolumeUsdc))
+        return null;
+      const jobsCompleted = sigRecord["jobsCompleted"];
+      if (typeof jobsCompleted !== "number" || !isFinite(jobsCompleted))
+        return null;
+      const avgRating = sigRecord["avgRating"];
+      if (typeof avgRating !== "number" || !isFinite(avgRating)) return null;
+      skillResult.reputation = {
+        score: repScore,
+        signals: { trustedBy, channelVolumeUsdc, jobsCompleted, avgRating }
+      };
+    }
     result.skill = skillResult;
   }
   return result;
@@ -577,11 +938,22 @@ function buildJobResultEvent(params, secretKey) {
       "DVM_MISSING_CONTENT"
     );
   }
+  if (params.attestationEventId !== void 0) {
+    if (!HEX_64_REGEX.test(params.attestationEventId)) {
+      throw new ToonError(
+        "Job result attestationEventId must be a 64-character lowercase hex string",
+        "DVM_INVALID_ATTESTATION_EVENT_ID"
+      );
+    }
+  }
   const tags = [
     ["e", params.requestEventId],
     ["p", params.customerPubkey],
     ["amount", params.amount, "usdc"]
   ];
+  if (params.attestationEventId !== void 0) {
+    tags.push(["attestation", params.attestationEventId]);
+  }
   return finalizeEvent5(
     {
       kind: params.kind,
@@ -711,42 +1083,834 @@ function parseJobResult(event) {
   const amount = amountTag[1];
   if (amount === void 0 || amount === "") return null;
   if (!/^\d+$/.test(amount)) return null;
-  return {
+  const attestationTag = event.tags.find(
+    (t) => t[0] === "attestation"
+  );
+  const attestationEventId = attestationTag?.[1];
+  const result = {
     kind: event.kind,
     requestEventId,
     customerPubkey,
     amount,
     content: event.content
   };
+  if (attestationEventId !== void 0 && HEX_64_REGEX.test(attestationEventId)) {
+    result.attestationEventId = attestationEventId;
+  }
+  return result;
+}
+function parseJobFeedback(event) {
+  if (event.kind !== JOB_FEEDBACK_KIND) {
+    return null;
+  }
+  const eTag = event.tags.find((t) => t[0] === "e");
+  if (!eTag) return null;
+  const requestEventId = eTag[1];
+  if (requestEventId === void 0 || !HEX_64_REGEX.test(requestEventId))
+    return null;
+  const pTag = event.tags.find((t) => t[0] === "p");
+  if (!pTag) return null;
+  const customerPubkey = pTag[1];
+  if (customerPubkey === void 0 || !HEX_64_REGEX.test(customerPubkey))
+    return null;
+  const statusTag = event.tags.find((t) => t[0] === "status");
+  if (!statusTag) return null;
+  const statusValue = statusTag[1];
+  if (statusValue === void 0) return null;
+  if (!VALID_STATUSES.has(statusValue)) {
+    return null;
+  }
+  return {
+    requestEventId,
+    customerPubkey,
+    status: statusValue,
+    content: event.content
+  };
+}
+
+// src/events/workflow.ts
+import { finalizeEvent as finalizeEvent6 } from "nostr-tools/pure";
+var HEX_64_REGEX2 = /^[0-9a-f]{64}$/;
+function buildWorkflowDefinitionEvent(params, secretKey) {
+  if (!params.steps || params.steps.length === 0) {
+    throw new ToonError(
+      "Workflow definition must have at least one step",
+      "DVM_WORKFLOW_INVALID_STEPS"
+    );
+  }
+  for (const step of params.steps) {
+    if (step.kind < 5e3 || step.kind > 5999) {
+      throw new ToonError(
+        `Workflow step kind must be in range 5000-5999, got ${step.kind}`,
+        "DVM_WORKFLOW_INVALID_STEPS"
+      );
+    }
+    if (typeof step.description !== "string" || step.description === "") {
+      throw new ToonError(
+        "Workflow step description must be a non-empty string",
+        "DVM_WORKFLOW_INVALID_STEPS"
+      );
+    }
+    if (step.targetProvider !== void 0 && !HEX_64_REGEX2.test(step.targetProvider)) {
+      throw new ToonError(
+        "Workflow step targetProvider must be a 64-character lowercase hex string",
+        "DVM_WORKFLOW_INVALID_PROVIDER"
+      );
+    }
+  }
+  if (typeof params.initialInput.data !== "string") {
+    throw new ToonError(
+      "Workflow definition initial input data must be a string",
+      "DVM_WORKFLOW_MISSING_INPUT"
+    );
+  }
+  if (!params.initialInput.type) {
+    throw new ToonError(
+      "Workflow definition initial input type is required",
+      "DVM_WORKFLOW_MISSING_INPUT"
+    );
+  }
+  if (typeof params.totalBid !== "string" || params.totalBid === "") {
+    throw new ToonError(
+      "Workflow definition totalBid must be a non-empty string (USDC micro-units)",
+      "DVM_WORKFLOW_INVALID_BID"
+    );
+  }
+  const stepsWithAllocation = params.steps.filter(
+    (s) => s.bidAllocation !== void 0
+  );
+  if (stepsWithAllocation.length > 0) {
+    let allocationSum;
+    let totalBidBigInt;
+    try {
+      allocationSum = 0n;
+      for (const step of stepsWithAllocation) {
+        allocationSum += BigInt(step.bidAllocation);
+      }
+      totalBidBigInt = BigInt(params.totalBid);
+    } catch {
+      throw new ToonError(
+        "Workflow bid amounts must be valid numeric strings (USDC micro-units)",
+        "DVM_WORKFLOW_INVALID_BID"
+      );
+    }
+    if (allocationSum > totalBidBigInt) {
+      throw new ToonError(
+        `Sum of step bid allocations (${allocationSum}) exceeds total bid (${totalBidBigInt})`,
+        "DVM_WORKFLOW_BID_OVERFLOW"
+      );
+    }
+  }
+  const contentBody = {
+    steps: params.steps.map((step) => {
+      const s = {
+        kind: step.kind,
+        description: step.description
+      };
+      if (step.targetProvider !== void 0) {
+        s["targetProvider"] = step.targetProvider;
+      }
+      if (step.bidAllocation !== void 0) {
+        s["bidAllocation"] = step.bidAllocation;
+      }
+      return s;
+    }),
+    initialInput: params.initialInput,
+    totalBid: params.totalBid
+  };
+  const contentJson = JSON.stringify(contentBody);
+  const tags = [];
+  const dTag = params.workflowId ?? `wf-${Date.now()}-${params.steps.length}`;
+  tags.push(["d", dTag]);
+  tags.push(["bid", params.totalBid, "usdc"]);
+  return finalizeEvent6(
+    {
+      kind: WORKFLOW_CHAIN_KIND,
+      content: contentJson,
+      tags,
+      created_at: Math.floor(Date.now() / 1e3)
+    },
+    secretKey
+  );
+}
+function parseWorkflowDefinition(event) {
+  if (event.kind !== WORKFLOW_CHAIN_KIND) {
+    return null;
+  }
+  let body;
+  try {
+    body = JSON.parse(event.content);
+  } catch {
+    return null;
+  }
+  if (typeof body !== "object" || body === null) {
+    return null;
+  }
+  const obj = body;
+  const rawSteps = obj["steps"];
+  if (!Array.isArray(rawSteps) || rawSteps.length === 0) {
+    return null;
+  }
+  const steps = [];
+  for (const rawStep of rawSteps) {
+    if (typeof rawStep !== "object" || rawStep === null) {
+      return null;
+    }
+    const stepObj = rawStep;
+    const kind = stepObj["kind"];
+    const description = stepObj["description"];
+    if (typeof kind !== "number" || typeof description !== "string") {
+      return null;
+    }
+    if (kind < 5e3 || kind > 5999) {
+      return null;
+    }
+    const step = { kind, description };
+    const targetProvider = stepObj["targetProvider"];
+    if (typeof targetProvider === "string" && targetProvider.length > 0) {
+      step.targetProvider = targetProvider;
+    }
+    const bidAllocation = stepObj["bidAllocation"];
+    if (typeof bidAllocation === "string" && bidAllocation.length > 0) {
+      step.bidAllocation = bidAllocation;
+    }
+    steps.push(step);
+  }
+  const rawInput = obj["initialInput"];
+  if (typeof rawInput !== "object" || rawInput === null) {
+    return null;
+  }
+  const inputObj = rawInput;
+  const inputData = inputObj["data"];
+  const inputType = inputObj["type"];
+  if (typeof inputData !== "string" || typeof inputType !== "string") {
+    return null;
+  }
+  const totalBid = obj["totalBid"];
+  if (typeof totalBid !== "string" || totalBid === "") {
+    return null;
+  }
+  return {
+    steps,
+    initialInput: { data: inputData, type: inputType },
+    totalBid,
+    content: event.content
+  };
+}
+
+// src/events/swarm.ts
+import { finalizeEvent as finalizeEvent7 } from "nostr-tools/pure";
+var HEX_64_REGEX3 = /^[0-9a-f]{64}$/;
+function buildSwarmRequestEvent(params, secretKey) {
+  if (!Number.isInteger(params.maxProviders) || params.maxProviders < 1) {
+    throw new ToonError(
+      `Swarm maxProviders must be a positive integer >= 1, got ${params.maxProviders}`,
+      "DVM_SWARM_INVALID_MAX_PROVIDERS"
+    );
+  }
+  const baseEvent = buildJobRequestEvent(params, secretKey);
+  const judge = params.judge ?? "customer";
+  const tags = [
+    ...baseEvent.tags,
+    ["swarm", params.maxProviders.toString()],
+    ["judge", judge]
+  ];
+  return finalizeEvent7(
+    {
+      kind: baseEvent.kind,
+      content: baseEvent.content,
+      tags,
+      created_at: baseEvent.created_at
+    },
+    secretKey
+  );
+}
+function buildSwarmSelectionEvent(params, secretKey) {
+  if (!HEX_64_REGEX3.test(params.swarmRequestEventId)) {
+    throw new ToonError(
+      "Swarm selection swarmRequestEventId must be a 64-character lowercase hex string",
+      "DVM_INVALID_EVENT_ID"
+    );
+  }
+  if (!HEX_64_REGEX3.test(params.winnerResultEventId)) {
+    throw new ToonError(
+      "Swarm selection winnerResultEventId must be a 64-character lowercase hex string",
+      "DVM_INVALID_EVENT_ID"
+    );
+  }
+  if (!HEX_64_REGEX3.test(params.customerPubkey)) {
+    throw new ToonError(
+      "Swarm selection customerPubkey must be a 64-character lowercase hex string",
+      "DVM_INVALID_PUBKEY"
+    );
+  }
+  const tags = [
+    ["e", params.swarmRequestEventId],
+    ["p", params.customerPubkey],
+    ["status", "success"],
+    ["winner", params.winnerResultEventId]
+  ];
+  return finalizeEvent7(
+    {
+      kind: JOB_FEEDBACK_KIND,
+      content: "",
+      tags,
+      created_at: Math.floor(Date.now() / 1e3)
+    },
+    secretKey
+  );
+}
+function parseSwarmRequest(event) {
+  const base = parseJobRequest(event);
+  if (!base) return null;
+  const swarmTag = event.tags.find((t) => t[0] === "swarm");
+  if (!swarmTag) return null;
+  const maxProvidersStr = swarmTag[1];
+  if (maxProvidersStr === void 0) return null;
+  const maxProviders = parseInt(maxProvidersStr, 10);
+  if (isNaN(maxProviders) || maxProviders < 1) return null;
+  const judgeTag = event.tags.find((t) => t[0] === "judge");
+  const judge = judgeTag?.[1] ?? "customer";
+  return {
+    ...base,
+    maxProviders,
+    judge
+  };
+}
+function parseSwarmSelection(event) {
+  if (event.kind !== JOB_FEEDBACK_KIND) return null;
+  const winnerTag = event.tags.find((t) => t[0] === "winner");
+  if (!winnerTag) return null;
+  const winnerResultEventId = winnerTag[1];
+  if (winnerResultEventId === void 0 || !HEX_64_REGEX3.test(winnerResultEventId))
+    return null;
+  const eTag = event.tags.find((t) => t[0] === "e");
+  if (!eTag) return null;
+  const swarmRequestEventId = eTag[1];
+  if (swarmRequestEventId === void 0 || !HEX_64_REGEX3.test(swarmRequestEventId))
+    return null;
+  return {
+    swarmRequestEventId,
+    winnerResultEventId
+  };
+}
+
+// src/events/prefix-claim.ts
+import { finalizeEvent as finalizeEvent8 } from "nostr-tools/pure";
+function buildPrefixClaimEvent(content, secretKey) {
+  return finalizeEvent8(
+    {
+      kind: PREFIX_CLAIM_KIND,
+      content: JSON.stringify(content),
+      tags: [],
+      created_at: Math.floor(Date.now() / 1e3)
+    },
+    secretKey
+  );
+}
+function parsePrefixClaimEvent(event) {
+  if (event.kind !== PREFIX_CLAIM_KIND) {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(event.content);
+    if (typeof parsed !== "object" || parsed === null) {
+      return null;
+    }
+    const obj = parsed;
+    const requestedPrefix = obj["requestedPrefix"];
+    if (typeof requestedPrefix !== "string" || requestedPrefix.length === 0) {
+      return null;
+    }
+    return { requestedPrefix };
+  } catch {
+    return null;
+  }
+}
+function buildPrefixGrantEvent(content, secretKey) {
+  return finalizeEvent8(
+    {
+      kind: PREFIX_GRANT_KIND,
+      content: JSON.stringify(content),
+      tags: [],
+      created_at: Math.floor(Date.now() / 1e3)
+    },
+    secretKey
+  );
+}
+function parsePrefixGrantEvent(event) {
+  if (event.kind !== PREFIX_GRANT_KIND) {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(event.content);
+    if (typeof parsed !== "object" || parsed === null) {
+      return null;
+    }
+    const obj = parsed;
+    const grantedPrefix = obj["grantedPrefix"];
+    const claimerPubkey = obj["claimerPubkey"];
+    const ilpAddress = obj["ilpAddress"];
+    if (typeof grantedPrefix !== "string" || grantedPrefix.length === 0) {
+      return null;
+    }
+    if (typeof claimerPubkey !== "string" || claimerPubkey.length === 0) {
+      return null;
+    }
+    if (typeof ilpAddress !== "string" || ilpAddress.length === 0) {
+      return null;
+    }
+    return {
+      grantedPrefix,
+      claimerPubkey,
+      ilpAddress
+    };
+  } catch {
+    return null;
+  }
+}
+
+// src/bootstrap/AttestationVerifier.ts
+var AttestationState = /* @__PURE__ */ ((AttestationState2) => {
+  AttestationState2["VALID"] = "valid";
+  AttestationState2["STALE"] = "stale";
+  AttestationState2["UNATTESTED"] = "unattested";
+  return AttestationState2;
+})(AttestationState || {});
+var DEFAULT_VALIDITY_SECONDS = 300;
+var DEFAULT_GRACE_SECONDS = 30;
+var AttestationVerifier = class {
+  knownGoodPcrs;
+  validitySeconds;
+  graceSeconds;
+  constructor(config) {
+    this.knownGoodPcrs = new Map(config.knownGoodPcrs);
+    const validity = config.validitySeconds ?? DEFAULT_VALIDITY_SECONDS;
+    const grace = config.graceSeconds ?? DEFAULT_GRACE_SECONDS;
+    if (!Number.isFinite(validity) || validity < 0) {
+      throw new Error(
+        `validitySeconds must be a non-negative finite number, got ${String(validity)}`
+      );
+    }
+    if (!Number.isFinite(grace) || grace < 0) {
+      throw new Error(
+        `graceSeconds must be a non-negative finite number, got ${String(grace)}`
+      );
+    }
+    this.validitySeconds = validity;
+    this.graceSeconds = grace;
+  }
+  /**
+   * 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) {
+    const pcr0Valid = this.knownGoodPcrs.get(attestation.pcr0) === true;
+    const pcr1Valid = this.knownGoodPcrs.get(attestation.pcr1) === true;
+    const pcr2Valid = this.knownGoodPcrs.get(attestation.pcr2) === true;
+    if (pcr0Valid && pcr1Valid && pcr2Valid) {
+      return { valid: true };
+    }
+    return { valid: false, reason: "PCR mismatch" };
+  }
+  /**
+   * 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, attestedAt, now) {
+    if (!Number.isFinite(attestedAt)) {
+      return "unattested" /* UNATTESTED */;
+    }
+    const currentTime = now ?? Math.floor(Date.now() / 1e3);
+    const validityEnd = attestedAt + this.validitySeconds;
+    const graceEnd = validityEnd + this.graceSeconds;
+    if (currentTime <= validityEnd) {
+      return "valid" /* VALID */;
+    }
+    if (currentTime <= graceEnd) {
+      return "stale" /* STALE */;
+    }
+    return "unattested" /* UNATTESTED */;
+  }
+  /**
+   * 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) {
+    const attested = peers.filter((p) => p.attested);
+    const nonAttested = peers.filter((p) => !p.attested);
+    return [...attested, ...nonAttested];
+  }
+};
+
+// src/events/attested-result-verifier.ts
+var AttestedResultVerifier = class {
+  attestationVerifier;
+  constructor(options) {
+    this.attestationVerifier = options.attestationVerifier;
+  }
+  /**
+   * Verifies that a Kind 6xxx result was computed in a valid TEE enclave.
+   *
+   * Performs three checks:
+   * (a) Pubkey match: attestationEvent.pubkey === resultEvent.pubkey
+   * (b) PCR validity: AttestationVerifier.verify(parsedAttestation.attestation)
+   * (c) Time validity: attestation was VALID at resultEvent.created_at
+   *
+   * @param resultEvent - The Kind 6xxx result Nostr event.
+   * @param _parsedResult - The parsed job result (reserved for future use).
+   * @param attestationEvent - The kind:10033 attestation Nostr event.
+   * @param parsedAttestation - The parsed attestation data.
+   * @returns Verification result with valid flag, reason, and attestation state.
+   */
+  verifyAttestedResult(resultEvent, _parsedResult, attestationEvent, parsedAttestation) {
+    if (attestationEvent.pubkey !== resultEvent.pubkey) {
+      return { valid: false, reason: "pubkey mismatch" };
+    }
+    const pcrResult = this.attestationVerifier.verify(
+      parsedAttestation.attestation
+    );
+    if (!pcrResult.valid) {
+      return { valid: false, reason: "PCR mismatch" };
+    }
+    const state = this.attestationVerifier.getAttestationState(
+      parsedAttestation.attestation,
+      attestationEvent.created_at,
+      resultEvent.created_at
+    );
+    if (state !== "valid" /* VALID */) {
+      return {
+        valid: false,
+        reason: "attestation expired at result creation time",
+        attestationState: state
+      };
+    }
+    return { valid: true, attestationState: "valid" /* VALID */ };
+  }
+};
+function hasRequireAttestation(params) {
+  return params.some(
+    (p) => p.key === "require_attestation" && p.value === "true"
+  );
+}
+
+// src/events/arweave-storage.ts
+import { finalizeEvent as finalizeEvent9 } from "nostr-tools/pure";
+var BASE64_REGEX2 = /^[A-Za-z0-9+/]*={0,2}$/;
+var UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+function isValidBase64(str) {
+  if (str.length === 0) return false;
+  if (!BASE64_REGEX2.test(str)) return false;
+  try {
+    Buffer.from(str, "base64");
+    return true;
+  } catch {
+    return false;
+  }
+}
+function buildBlobStorageRequest(params, secretKey) {
+  if (!params.blobData || params.blobData.length === 0) {
+    throw new ToonError(
+      "Blob storage request blobData is required and must not be empty",
+      "DVM_MISSING_INPUT"
+    );
+  }
+  if (typeof params.bid !== "string" || params.bid === "") {
+    throw new ToonError(
+      "Blob storage request bid must be a non-empty string (USDC micro-units)",
+      "DVM_INVALID_BID"
+    );
+  }
+  const contentType = params.contentType ?? "application/octet-stream";
+  const base64Blob = params.blobData.toString("base64");
+  const tags = [];
+  tags.push(["i", base64Blob, "blob"]);
+  tags.push(["bid", params.bid, "usdc"]);
+  tags.push(["output", contentType]);
+  if (params.params !== void 0) {
+    for (const p of params.params) {
+      tags.push(["param", p.key, p.value]);
+    }
+  }
+  return finalizeEvent9(
+    {
+      kind: BLOB_STORAGE_REQUEST_KIND,
+      content: "",
+      tags,
+      created_at: Math.floor(Date.now() / 1e3)
+    },
+    secretKey
+  );
+}
+function parseBlobStorageRequest(event) {
+  if (event.kind !== BLOB_STORAGE_REQUEST_KIND) {
+    return null;
+  }
+  const iTag = event.tags.find((t) => t[0] === "i");
+  if (!iTag) return null;
+  const base64Data = iTag[1];
+  const inputType = iTag[2];
+  if (base64Data === void 0 || base64Data === "") return null;
+  if (inputType !== "blob") return null;
+  if (!isValidBase64(base64Data)) {
+    return null;
+  }
+  const bidTag = event.tags.find((t) => t[0] === "bid");
+  if (!bidTag) return null;
+  const bidAmount = bidTag[1];
+  if (bidAmount === void 0 || bidAmount === "") return null;
+  const outputTag = event.tags.find((t) => t[0] === "output");
+  const contentType = outputTag?.[1] && outputTag[1] !== "" ? outputTag[1] : "application/octet-stream";
+  const blobData = Buffer.from(base64Data, "base64");
+  const paramTags = event.tags.filter((t) => t[0] === "param");
+  const paramMap = /* @__PURE__ */ new Map();
+  for (const pt of paramTags) {
+    const key = pt[1];
+    const value = pt[2];
+    if (key !== void 0 && value !== void 0) {
+      paramMap.set(key, value);
+    }
+  }
+  const result = {
+    blobData,
+    contentType
+  };
+  const uploadId = paramMap.get("uploadId");
+  if (uploadId !== void 0 && UUID_REGEX.test(uploadId)) {
+    result.uploadId = uploadId;
+  }
+  const chunkIndexStr = paramMap.get("chunkIndex");
+  if (chunkIndexStr !== void 0) {
+    const chunkIndex = parseInt(chunkIndexStr, 10);
+    if (!isNaN(chunkIndex) && chunkIndex >= 0) {
+      result.chunkIndex = chunkIndex;
+    }
+  }
+  const totalChunksStr = paramMap.get("totalChunks");
+  if (totalChunksStr !== void 0) {
+    const totalChunks = parseInt(totalChunksStr, 10);
+    if (!isNaN(totalChunks) && totalChunks > 0) {
+      result.totalChunks = totalChunks;
+    }
+  }
+  return result;
+}
+
+// src/events/reputation.ts
+import { finalizeEvent as finalizeEvent10 } from "nostr-tools/pure";
+var HEX_64_REGEX4 = /^[0-9a-f]{64}$/;
+function buildJobReviewEvent(params, secretKey) {
+  if (!HEX_64_REGEX4.test(params.jobRequestEventId)) {
+    throw new ToonError(
+      "Job review jobRequestEventId must be a 64-character lowercase hex string",
+      "REPUTATION_INVALID_JOB_REQUEST_EVENT_ID"
+    );
+  }
+  if (!HEX_64_REGEX4.test(params.targetPubkey)) {
+    throw new ToonError(
+      "Job review targetPubkey must be a 64-character lowercase hex string",
+      "REPUTATION_INVALID_TARGET_PUBKEY"
+    );
+  }
+  if (typeof params.rating !== "number" || !Number.isInteger(params.rating) || params.rating < 1 || params.rating > 5) {
+    throw new ToonError(
+      `Job review rating must be an integer 1-5, got ${String(params.rating)}`,
+      "REPUTATION_INVALID_RATING"
+    );
+  }
+  if (params.role !== "customer" && params.role !== "provider") {
+    throw new ToonError(
+      `Job review role must be 'customer' or 'provider', got '${String(params.role)}'`,
+      "REPUTATION_INVALID_ROLE"
+    );
+  }
+  const tags = [
+    ["d", params.jobRequestEventId],
+    ["p", params.targetPubkey],
+    ["rating", params.rating.toString()],
+    ["role", params.role]
+  ];
+  return finalizeEvent10(
+    {
+      kind: JOB_REVIEW_KIND,
+      content: params.content ?? "",
+      tags,
+      created_at: Math.floor(Date.now() / 1e3)
+    },
+    secretKey
+  );
+}
+function parseJobReview(event) {
+  if (event.kind !== JOB_REVIEW_KIND) {
+    return null;
+  }
+  const dTag = event.tags.find((t) => t[0] === "d");
+  if (!dTag) return null;
+  const jobRequestEventId = dTag[1];
+  if (jobRequestEventId === void 0 || !HEX_64_REGEX4.test(jobRequestEventId))
+    return null;
+  const pTag = event.tags.find((t) => t[0] === "p");
+  if (!pTag) return null;
+  const targetPubkey = pTag[1];
+  if (targetPubkey === void 0 || !HEX_64_REGEX4.test(targetPubkey))
+    return null;
+  const ratingTag = event.tags.find((t) => t[0] === "rating");
+  if (!ratingTag) return null;
+  const ratingStr = ratingTag[1];
+  if (ratingStr === void 0) return null;
+  const rating = Number(ratingStr);
+  if (!Number.isInteger(rating) || rating < 1 || rating > 5) return null;
+  const roleTag = event.tags.find((t) => t[0] === "role");
+  if (!roleTag) return null;
+  const role = roleTag[1];
+  if (role !== "customer" && role !== "provider") return null;
+  return {
+    jobRequestEventId,
+    targetPubkey,
+    rating,
+    role,
+    content: event.content
+  };
+}
+function buildWotDeclarationEvent(params, secretKey) {
+  if (!HEX_64_REGEX4.test(params.targetPubkey)) {
+    throw new ToonError(
+      "WoT declaration targetPubkey must be a 64-character lowercase hex string",
+      "REPUTATION_INVALID_TARGET_PUBKEY"
+    );
+  }
+  const tags = [
+    ["d", params.targetPubkey],
+    ["p", params.targetPubkey]
+  ];
+  return finalizeEvent10(
+    {
+      kind: WEB_OF_TRUST_KIND,
+      content: params.content ?? "",
+      tags,
+      created_at: Math.floor(Date.now() / 1e3)
+    },
+    secretKey
+  );
 }
-function parseJobFeedback(event) {
-  if (event.kind !== JOB_FEEDBACK_KIND) {
+function parseWotDeclaration(event) {
+  if (event.kind !== WEB_OF_TRUST_KIND) {
     return null;
   }
-  const eTag = event.tags.find((t) => t[0] === "e");
-  if (!eTag) return null;
-  const requestEventId = eTag[1];
-  if (requestEventId === void 0 || !HEX_64_REGEX.test(requestEventId))
-    return null;
+  const dTag = event.tags.find((t) => t[0] === "d");
+  if (!dTag) return null;
+  const dValue = dTag[1];
+  if (dValue === void 0) return null;
   const pTag = event.tags.find((t) => t[0] === "p");
   if (!pTag) return null;
-  const customerPubkey = pTag[1];
-  if (customerPubkey === void 0 || !HEX_64_REGEX.test(customerPubkey))
+  const targetPubkey = pTag[1];
+  if (targetPubkey === void 0 || !HEX_64_REGEX4.test(targetPubkey))
     return null;
-  const statusTag = event.tags.find((t) => t[0] === "status");
-  if (!statusTag) return null;
-  const statusValue = statusTag[1];
-  if (statusValue === void 0) return null;
-  if (!VALID_STATUSES.has(statusValue)) {
-    return null;
-  }
+  if (dValue !== targetPubkey) return null;
   return {
-    requestEventId,
-    customerPubkey,
-    status: statusValue,
+    targetPubkey,
+    declarerPubkey: event.pubkey,
     content: event.content
   };
 }
+var ReputationScoreCalculator = class {
+  /**
+   * Computes the composite reputation score from pre-computed signals.
+   *
+   * @param signals - The individual signal values.
+   * @returns The composite score with individual signals.
+   */
+  calculateScore(signals) {
+    const score = signals.trustedBy * 100 + Math.log10(Math.max(1, signals.channelVolumeUsdc)) * 10 + signals.jobsCompleted * 5 + signals.avgRating * 20;
+    if (!isFinite(score)) {
+      return { score: 0, signals };
+    }
+    return { score, signals };
+  }
+  /**
+   * Computes the threshold-filtered trusted_by count from WoT declarations.
+   *
+   * Declarers with non-zero channel volume contribute 1 to the count.
+   * Declarers with zero channel volume contribute 0 (sybil defense).
+   *
+   * @param wotDeclarations - Parsed WoT declarations targeting the provider.
+   * @param getChannelVolume - Callback to look up a declarer's channel volume.
+   * @returns The count of WoT declarations from non-zero-volume declarers.
+   */
+  computeTrustedBy(wotDeclarations, getChannelVolume) {
+    let count = 0;
+    for (const declaration of wotDeclarations) {
+      const volume = getChannelVolume(declaration.declarerPubkey);
+      if (volume > 0) {
+        count += 1;
+      }
+    }
+    return count;
+  }
+  /**
+   * Computes the average rating from verified customer reviews only.
+   *
+   * Reviews are provided as tuples of `{ review, reviewerPubkey }` so the
+   * calculator can filter by the verified customer set. Reviews from pubkeys
+   * NOT in `verifiedCustomerPubkeys` are excluded entirely (customer-gate
+   * sybil defense per E6-R013).
+   *
+   * @param reviews - Parsed job reviews with reviewer pubkeys.
+   * @param verifiedCustomerPubkeys - Set of pubkeys that authored Kind 5xxx requests.
+   * @returns The mean rating from verified reviews, or 0 when no verified reviews exist.
+   */
+  computeAvgRating(reviews, verifiedCustomerPubkeys) {
+    let sum = 0;
+    let count = 0;
+    for (const { review, reviewerPubkey } of reviews) {
+      if (!verifiedCustomerPubkeys.has(reviewerPubkey)) {
+        continue;
+      }
+      if (Number.isInteger(review.rating) && review.rating >= 1 && review.rating <= 5) {
+        sum += review.rating;
+        count += 1;
+      }
+    }
+    return count === 0 ? 0 : sum / count;
+  }
+};
+function hasMinReputation(params) {
+  const param = params.find((p) => p.key === "min_reputation");
+  if (param === void 0) {
+    return null;
+  }
+  const trimmed = param.value.trim();
+  const numericValue = Number(trimmed);
+  if (trimmed === "" || isNaN(numericValue) || !isFinite(numericValue)) {
+    throw new ToonError(
+      `min_reputation value must be numeric, got '${param.value}'`,
+      "REPUTATION_INVALID_MIN_REPUTATION"
+    );
+  }
+  return numericValue;
+}
 
 // src/discovery/NostrPeerDiscovery.ts
 import { SimplePool } from "nostr-tools/pool";
@@ -1456,6 +2620,98 @@ async function publishSeedRelayEntry(config) {
   return { publishedTo, eventId: event.id };
 }
 
+// src/fee/calculate-route-amount.ts
+function calculateRouteAmount(params) {
+  const { basePricePerByte, packetByteLength, hopFees } = params;
+  if (packetByteLength < 0) {
+    return 0n;
+  }
+  const bytes = BigInt(packetByteLength);
+  const baseAmount = basePricePerByte * bytes;
+  const intermediaryFees = hopFees.reduce((sum, fee) => sum + fee * bytes, 0n);
+  return baseAmount + intermediaryFees;
+}
+
+// src/fee/resolve-route-fees.ts
+var _cachedPeersRef = null;
+var _cachedPeerFingerprint = "";
+var _cachedPeerMap = null;
+function peerFingerprint(peers) {
+  let fp = `${peers.length}:`;
+  for (const p of peers) {
+    fp += `${p.peerInfo.ilpAddress}=${p.peerInfo.feePerByte};`;
+  }
+  return fp;
+}
+function getPeerByAddressMap(discoveredPeers) {
+  const fp = peerFingerprint(discoveredPeers);
+  if (_cachedPeersRef === discoveredPeers && _cachedPeerFingerprint === fp && _cachedPeerMap) {
+    return _cachedPeerMap;
+  }
+  const peerByAddress = /* @__PURE__ */ new Map();
+  for (const peer of discoveredPeers) {
+    peerByAddress.set(peer.peerInfo.ilpAddress, peer);
+    if (peer.peerInfo.ilpAddresses) {
+      for (const addr of peer.peerInfo.ilpAddresses) {
+        peerByAddress.set(addr, peer);
+      }
+    }
+  }
+  _cachedPeersRef = discoveredPeers;
+  _cachedPeerFingerprint = fp;
+  _cachedPeerMap = peerByAddress;
+  return peerByAddress;
+}
+function resolveRouteFees(params) {
+  const { destination, ownIlpAddress, discoveredPeers } = params;
+  if (!destination || !destination.trim() || !ownIlpAddress || !ownIlpAddress.trim()) {
+    return { hopFees: [], warnings: [] };
+  }
+  const senderSegments = ownIlpAddress.split(".");
+  const destSegments = destination.split(".");
+  let lcaLength = 0;
+  const minLength = Math.min(senderSegments.length, destSegments.length);
+  for (let i = 0; i < minLength; i++) {
+    if (senderSegments[i] === destSegments[i]) {
+      lcaLength = i + 1;
+    } else {
+      break;
+    }
+  }
+  const intermediaryPrefixes = [];
+  for (let i = lcaLength; i < destSegments.length - 1; i++) {
+    const prefix = destSegments.slice(0, i + 1).join(".");
+    intermediaryPrefixes.push(prefix);
+  }
+  if (intermediaryPrefixes.length === 0) {
+    return { hopFees: [], warnings: [] };
+  }
+  const peerByAddress = getPeerByAddressMap(discoveredPeers);
+  const hopFees = [];
+  const warnings = [];
+  for (const prefix of intermediaryPrefixes) {
+    const peer = peerByAddress.get(prefix);
+    if (peer) {
+      let fee;
+      try {
+        fee = BigInt(peer.peerInfo.feePerByte ?? "0");
+      } catch {
+        fee = 0n;
+        warnings.push(
+          `Invalid feePerByte "${peer.peerInfo.feePerByte}" at ${prefix}: defaulting to 0`
+        );
+      }
+      hopFees.push(fee < 0n ? 0n : fee);
+    } else {
+      hopFees.push(0n);
+      warnings.push(
+        `Unknown intermediary at ${prefix}: defaulting feePerByte to 0`
+      );
+    }
+  }
+  return { hopFees, warnings };
+}
+
 // src/settlement/settlement.ts
 function negotiateSettlementChain(requesterChains, responderChains, requesterPreferredTokens, responderPreferredTokens) {
   const responderSet = new Set(responderChains);
@@ -1788,29 +3044,12 @@ var BootstrapService = class {
           const tokenNetwork = peerInfo.tokenNetworks?.[negotiatedChain];
           if (peerAddress) {
             console.log(
-              `[Bootstrap] Opening channel on ${negotiatedChain} with ${registeredPeerId}...`
+              `[Bootstrap] Negotiated ${negotiatedChain} with ${registeredPeerId} (lazy \u2014 channel deferred)`
             );
-            const channelResult = await this.channelClient.openChannel({
-              peerId: registeredPeerId,
-              chain: negotiatedChain,
-              token: tokenAddress,
-              tokenNetwork,
-              peerAddress,
-              initialDeposit: "100000",
-              settlementTimeout: 86400
-            });
-            result.channelId = channelResult.channelId;
             result.negotiatedChain = negotiatedChain;
             result.settlementAddress = peerAddress;
-            console.log(
-              `[Bootstrap] Opened channel ${channelResult.channelId} with ${registeredPeerId}`
-            );
-            this.emit({
-              type: "bootstrap:channel-opened",
-              peerId: registeredPeerId,
-              channelId: channelResult.channelId,
-              negotiatedChain
-            });
+            result.tokenAddress = tokenAddress;
+            result.tokenNetwork = tokenNetwork;
             if (this.connectorAdmin) {
               await this.connectorAdmin.addPeer({
                 id: registeredPeerId,
@@ -1821,10 +3060,7 @@ var BootstrapService = class {
                   preference: negotiatedChain,
                   ...peerAddress && { evmAddress: peerAddress },
                   ...tokenAddress && { tokenAddress },
-                  ...tokenNetwork && { tokenNetworkAddress: tokenNetwork },
-                  ...channelResult.channelId && {
-                    channelId: channelResult.channelId
-                  }
+                  ...tokenNetwork && { tokenNetworkAddress: tokenNetwork }
                 }
               });
             }
@@ -1885,7 +3121,7 @@ var BootstrapService = class {
     }
     if (ilpResult.accepted) {
       console.log(
-        `[Bootstrap] Announced to ${result.registeredPeerId} via ILP (fulfillment: ${ilpResult.fulfillment}, eventId: ${ilpInfoEvent.id})`
+        `[Bootstrap] Announced to ${result.registeredPeerId} via ILP (eventId: ${ilpInfoEvent.id})`
       );
       this.emit({
         type: "bootstrap:announced",
@@ -2148,6 +3384,56 @@ var BootstrapService = class {
       );
     }
   }
+  /**
+   * Re-advertise own kind:10032 to all previously bootstrapped peers.
+   *
+   * Called after topology changes (addUpstreamPeer/removeUpstreamPeer) to
+   * propagate updated ILP address lists to the network. Uses the same
+   * ILP-first announcement path as the initial Phase 2 bootstrap.
+   *
+   * For non-ILP mode, publishes directly to each peer's relay URL.
+   *
+   * @param results - The bootstrap results from the initial bootstrap() call
+   * @returns Number of peers successfully re-announced to
+   */
+  async republish(results) {
+    if (results.length === 0) {
+      return 0;
+    }
+    let successCount = 0;
+    if (this.ilpClient && this.toonEncoder) {
+      for (const result of results) {
+        try {
+          await this.announceViaIlp(result);
+          successCount++;
+        } catch (error) {
+          const reason = error instanceof Error ? error.message : "Unknown error";
+          this.emit({
+            type: "bootstrap:announce-failed",
+            peerId: result.registeredPeerId,
+            reason: `republish: ${reason}`
+          });
+          console.warn(
+            `[Bootstrap] Republish failed for ${result.registeredPeerId}:`,
+            reason
+          );
+        }
+      }
+    } else {
+      for (const result of results) {
+        try {
+          await this.publishOurInfo(result.knownPeer.relayUrl);
+          successCount++;
+        } catch (error) {
+          console.warn(
+            `[Bootstrap] Republish to ${result.knownPeer.relayUrl} failed:`,
+            error instanceof Error ? error.message : "Unknown error"
+          );
+        }
+      }
+    }
+    return successCount;
+  }
   /**
    * Get our pubkey.
    */
@@ -2170,10 +3456,11 @@ function createDiscoveryTracker(config) {
   const pubkey = getPublicKey4(config.secretKey);
   const excludedPubkeys = /* @__PURE__ */ new Set([pubkey]);
   let connectorAdmin;
-  let channelClient;
+  let _channelClient;
   let listeners = [];
   const discoveredPeers = /* @__PURE__ */ new Map();
   const peeredPubkeys = /* @__PURE__ */ new Set();
+  const peerNegotiations = /* @__PURE__ */ new Map();
   const peerTimestamps = /* @__PURE__ */ new Map();
   function emit(event) {
     for (const listener of listeners) {
@@ -2197,7 +3484,8 @@ function createDiscoveryTracker(config) {
           });
         }).catch((error) => {
           console.warn(
-            `[DiscoveryTracker] Failed to deregister ${peerId}:`,
+            "[DiscoveryTracker] Failed to deregister %s: %s",
+            peerId,
             error instanceof Error ? error.message : "Unknown error"
           );
         });
@@ -2278,7 +3566,8 @@ function createDiscoveryTracker(config) {
         peeredPubkeys.delete(targetPubkey);
         const reason = error instanceof Error ? error.message : "Unknown error";
         console.warn(
-          `[DiscoveryTracker] Failed to register ${peerId}:`,
+          "[DiscoveryTracker] Failed to register %s: %s",
+          peerId,
           reason
         );
         emit({
@@ -2288,7 +3577,7 @@ function createDiscoveryTracker(config) {
         });
         return;
       }
-      if (channelClient && config.settlementInfo?.supportedChains?.length && peerInfo.supportedChains?.length && peerInfo.settlementAddresses) {
+      if (config.settlementInfo?.supportedChains?.length && peerInfo.supportedChains?.length && peerInfo.settlementAddresses) {
         try {
           const negotiatedChain = negotiateSettlementChain(
             config.settlementInfo.supportedChains,
@@ -2305,44 +3594,25 @@ function createDiscoveryTracker(config) {
             );
             const tokenNetwork = peerInfo.tokenNetworks?.[negotiatedChain];
             if (peerAddress) {
-              const channelResult = await channelClient.openChannel({
-                peerId,
+              peerNegotiations.set(peerId, {
                 chain: negotiatedChain,
-                token: tokenAddress,
-                tokenNetwork,
-                peerAddress,
-                initialDeposit: "100000",
-                settlementTimeout: 86400
-              });
-              await admin.addPeer({
-                id: peerId,
-                url: peerInfo.btpEndpoint,
-                authToken: "",
-                routes: [{ prefix: peerInfo.ilpAddress }],
-                settlement: {
-                  preference: negotiatedChain,
-                  ...peerAddress && { evmAddress: peerAddress },
-                  ...tokenAddress && { tokenAddress },
-                  ...tokenNetwork && {
-                    tokenNetworkAddress: tokenNetwork
-                  },
-                  ...channelResult.channelId && {
-                    channelId: channelResult.channelId
-                  }
-                }
-              });
-              emit({
-                type: "bootstrap:channel-opened",
-                peerId,
-                channelId: channelResult.channelId,
-                negotiatedChain
+                chainType: negotiatedChain.split(":")[0] ?? negotiatedChain,
+                settlementAddress: peerAddress,
+                tokenAddress,
+                tokenNetwork
               });
+              console.log(
+                "[DiscoveryTracker] Negotiated %s with %s (lazy \u2014 channel deferred)",
+                negotiatedChain,
+                peerId
+              );
             }
           }
         } catch (error) {
           const reason = error instanceof Error ? error.message : "Unknown error";
           console.warn(
-            `[DiscoveryTracker] Settlement failed for ${peerId}:`,
+            "[DiscoveryTracker] Settlement negotiation failed for %s: %s",
+            peerId,
             reason
           );
           emit({
@@ -2358,6 +3628,9 @@ function createDiscoveryTracker(config) {
         (p) => !peeredPubkeys.has(p.pubkey)
       );
     },
+    getAllDiscoveredPeers() {
+      return [...discoveredPeers.values()];
+    },
     isPeered(targetPubkey) {
       return peeredPubkeys.has(targetPubkey);
     },
@@ -2377,7 +3650,10 @@ function createDiscoveryTracker(config) {
       connectorAdmin = admin;
     },
     setChannelClient(client) {
-      channelClient = client;
+      _channelClient = client;
+    },
+    getPeerNegotiation(peerId) {
+      return peerNegotiations.get(peerId);
     },
     addExcludedPubkeys(pubkeys) {
       for (const pk of pubkeys) {
@@ -2425,7 +3701,6 @@ function createHttpIlpClient(baseUrl) {
       const data = await response.json();
       return {
         accepted: data["accepted"] ?? data["fulfilled"] ?? false,
-        fulfillment: data["fulfillment"],
         data: data["data"],
         code: data["code"],
         message: data["message"]
@@ -2437,29 +3712,21 @@ var createHttpRuntimeClient = createHttpIlpClient;
 var createAgentRuntimeClient = createHttpIlpClient;
 
 // src/bootstrap/direct-ilp-client.ts
-import { createHash } from "crypto";
-function createDirectIlpClient(connector, config) {
+function createDirectIlpClient(connector, _config) {
   return {
     async sendIlpPacket(params) {
       try {
         const amount = BigInt(params.amount);
         const data = Uint8Array.from(Buffer.from(params.data, "base64"));
-        let executionCondition;
-        if (data.length > 0) {
-          const fulfillment = createHash("sha256").update(data).digest();
-          executionCondition = createHash("sha256").update(fulfillment).digest();
-        }
         const result = await connector.sendPacket({
           destination: params.destination,
           amount,
           data,
-          executionCondition,
           expiresAt: new Date(Date.now() + 3e4)
         });
         if (result.type === "fulfill" || result.type === 13) {
           return {
             accepted: true,
-            fulfillment: Buffer.from(result.fulfillment).toString("base64"),
             data: result.data ? Buffer.from(result.data).toString("base64") : void 0
           };
         }
@@ -2638,7 +3905,6 @@ function createHttpIlpClient2(connectorUrl) {
         if (result["accept"] || result["accepted"]) {
           return {
             accepted: true,
-            fulfillment: result["fulfillment"],
             data: result["data"]
           };
         } else {
@@ -2726,101 +3992,6 @@ function createHttpChannelClient(adminUrl) {
   };
 }
 
-// src/bootstrap/AttestationVerifier.ts
-var AttestationState = /* @__PURE__ */ ((AttestationState2) => {
-  AttestationState2["VALID"] = "valid";
-  AttestationState2["STALE"] = "stale";
-  AttestationState2["UNATTESTED"] = "unattested";
-  return AttestationState2;
-})(AttestationState || {});
-var DEFAULT_VALIDITY_SECONDS = 300;
-var DEFAULT_GRACE_SECONDS = 30;
-var AttestationVerifier = class {
-  knownGoodPcrs;
-  validitySeconds;
-  graceSeconds;
-  constructor(config) {
-    this.knownGoodPcrs = new Map(config.knownGoodPcrs);
-    const validity = config.validitySeconds ?? DEFAULT_VALIDITY_SECONDS;
-    const grace = config.graceSeconds ?? DEFAULT_GRACE_SECONDS;
-    if (!Number.isFinite(validity) || validity < 0) {
-      throw new Error(
-        `validitySeconds must be a non-negative finite number, got ${String(validity)}`
-      );
-    }
-    if (!Number.isFinite(grace) || grace < 0) {
-      throw new Error(
-        `graceSeconds must be a non-negative finite number, got ${String(grace)}`
-      );
-    }
-    this.validitySeconds = validity;
-    this.graceSeconds = grace;
-  }
-  /**
-   * 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) {
-    const pcr0Valid = this.knownGoodPcrs.get(attestation.pcr0) === true;
-    const pcr1Valid = this.knownGoodPcrs.get(attestation.pcr1) === true;
-    const pcr2Valid = this.knownGoodPcrs.get(attestation.pcr2) === true;
-    if (pcr0Valid && pcr1Valid && pcr2Valid) {
-      return { valid: true };
-    }
-    return { valid: false, reason: "PCR mismatch" };
-  }
-  /**
-   * 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, attestedAt, now) {
-    if (!Number.isFinite(attestedAt)) {
-      return "unattested" /* UNATTESTED */;
-    }
-    const currentTime = now ?? Math.floor(Date.now() / 1e3);
-    const validityEnd = attestedAt + this.validitySeconds;
-    const graceEnd = validityEnd + this.graceSeconds;
-    if (currentTime <= validityEnd) {
-      return "valid" /* VALID */;
-    }
-    if (currentTime <= graceEnd) {
-      return "stale" /* STALE */;
-    }
-    return "unattested" /* UNATTESTED */;
-  }
-  /**
-   * 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) {
-    const attested = peers.filter((p) => p.attested);
-    const nonAttested = peers.filter((p) => !p.attested);
-    return [...attested, ...nonAttested];
-  }
-};
-
 // src/bootstrap/AttestationBootstrap.ts
 var AttestationBootstrap = class {
   config;
@@ -2978,7 +4149,19 @@ function createToonNode(config) {
       }
       try {
         if (config.connector.setPacketHandler) {
-          config.connector.setPacketHandler(config.handlePacket);
+          const adaptedHandler = async (request) => {
+            const result = await config.handlePacket(request);
+            if (result.accept) {
+              return result;
+            }
+            const adapted = result;
+            adapted.rejectReason = {
+              code: result.code,
+              message: result.message
+            };
+            return adapted;
+          };
+          config.connector.setPacketHandler(adaptedHandler);
         }
         const results = await bootstrapService.bootstrap(
           config.additionalPeersJson
@@ -3079,6 +4262,97 @@ function buildEip712Domain(config) {
     verifyingContract: config.tokenNetworkAddress
   };
 }
+var SOLANA_CHAIN_PRESETS = {
+  "solana-devnet": {
+    name: "solana-devnet",
+    chainType: "solana",
+    rpcUrl: "http://localhost:19899",
+    programId: "",
+    // TBD: set after program deployment
+    cluster: "devnet"
+  }
+};
+var MINA_CHAIN_PRESETS = {
+  "mina-devnet": {
+    name: "mina-devnet",
+    chainType: "mina",
+    graphqlUrl: "http://localhost:19085/graphql",
+    zkAppAddress: "",
+    // TBD: set after zkApp deployment
+    network: "devnet"
+  }
+};
+function resolveSolanaChainConfig(name) {
+  const preset = SOLANA_CHAIN_PRESETS[name];
+  if (!preset) {
+    const validNames = Object.keys(SOLANA_CHAIN_PRESETS).join(", ");
+    throw new ToonError(
+      `Unknown Solana chain "${name}". Valid Solana chains: ${validNames}`,
+      "INVALID_CHAIN"
+    );
+  }
+  const resolved = { ...preset };
+  const envRpcUrl = process.env["SOLANA_RPC_URL"];
+  if (envRpcUrl) {
+    resolved.rpcUrl = envRpcUrl;
+  }
+  const envProgramId = process.env["SOLANA_PROGRAM_ID"];
+  if (envProgramId) {
+    resolved.programId = envProgramId;
+  }
+  return resolved;
+}
+function resolveMinaChainConfig(name) {
+  const preset = MINA_CHAIN_PRESETS[name];
+  if (!preset) {
+    const validNames = Object.keys(MINA_CHAIN_PRESETS).join(", ");
+    throw new ToonError(
+      `Unknown Mina chain "${name}". Valid Mina chains: ${validNames}`,
+      "INVALID_CHAIN"
+    );
+  }
+  const resolved = { ...preset };
+  const envGraphqlUrl = process.env["MINA_GRAPHQL_URL"];
+  if (envGraphqlUrl) {
+    resolved.graphqlUrl = envGraphqlUrl;
+  }
+  const envZkAppAddress = process.env["MINA_ZKAPP_ADDRESS"];
+  if (envZkAppAddress) {
+    resolved.zkAppAddress = envZkAppAddress;
+  }
+  return resolved;
+}
+function buildEvmProviderEntry(config, keyId) {
+  return {
+    chainType: "evm",
+    chainId: `evm:${config.chainId}`,
+    rpcUrl: config.rpcUrl,
+    registryAddress: config.registryAddress,
+    keyId
+  };
+}
+function buildSolanaProviderEntry(config, keyId) {
+  return {
+    chainType: "solana",
+    chainId: `solana:${config.cluster}`,
+    rpcUrl: config.rpcUrl,
+    programId: config.programId,
+    keyId,
+    cluster: config.cluster,
+    ...config.tokenMint && { tokenMint: config.tokenMint }
+  };
+}
+function buildMinaProviderEntry(config, keyId) {
+  return {
+    chainType: "mina",
+    chainId: `mina:${config.network}`,
+    graphqlUrl: config.graphqlUrl,
+    zkAppAddress: config.zkAppAddress,
+    ...keyId && { keyId },
+    ...config.tokenId && { tokenId: config.tokenId },
+    network: config.network
+  };
+}
 
 // src/x402/build-ilp-prepare.ts
 function buildIlpPrepare(params) {
@@ -3165,7 +4439,7 @@ import { execFile as execFileCb } from "child_process";
 import { readFile, mkdtemp, cp, writeFile, rm } from "fs/promises";
 import { tmpdir } from "os";
 import path from "path";
-import { createHash as createHash2 } from "crypto";
+import { createHash } from "crypto";
 function execFileAsync(cmd, args, options) {
   return new Promise((resolve, reject) => {
     execFileCb(cmd, args, options, (error, stdout, stderr) => {
@@ -3226,19 +4500,19 @@ var NixBuilder = class {
         );
       }
       const imageData = await readFile(imagePath);
-      const sha256 = createHash2("sha256").update(imageData).digest("hex");
+      const sha256 = createHash("sha256").update(imageData).digest("hex");
       const imageHash = `sha256:${sha256}`;
-      const pcr0 = createHash2("sha384").update(imageData).digest("hex");
+      const pcr0 = createHash("sha384").update(imageData).digest("hex");
       const KERNEL_REGION_SIZE = 1024 * 1024;
       const kernelRegion = imageData.subarray(
         0,
         Math.min(KERNEL_REGION_SIZE, imageData.length)
       );
-      const pcr1 = createHash2("sha384").update(kernelRegion).digest("hex");
+      const pcr1 = createHash("sha384").update(kernelRegion).digest("hex");
       const appRegion = imageData.subarray(
         Math.min(KERNEL_REGION_SIZE, imageData.length)
       );
-      const pcr2 = appRegion.length > 0 ? createHash2("sha384").update(appRegion).digest("hex") : createHash2("sha384").update("pcr2:").update(imageData).digest("hex");
+      const pcr2 = appRegion.length > 0 ? createHash("sha384").update(appRegion).digest("hex") : createHash("sha384").update("pcr2:").update(imageData).digest("hex");
       return {
         imageHash,
         pcr0,
@@ -3429,29 +4703,43 @@ function createLogger(config) {
 // src/index.ts
 var VERSION = "0.1.0";
 export {
+  AddressRegistry,
   ArDrivePeerRegistry,
   AttestationBootstrap,
   AttestationState,
   AttestationVerifier,
+  AttestedResultVerifier,
+  BLOB_STORAGE_REQUEST_KIND,
+  BLOB_STORAGE_RESULT_KIND,
   BootstrapError,
   BootstrapService,
   CHAIN_PRESETS,
   GenesisPeerLoader,
   ILP_PEER_INFO_KIND,
+  ILP_ROOT_PREFIX,
   IMAGE_GENERATION_KIND,
   InvalidEventError,
   JOB_FEEDBACK_KIND,
   JOB_REQUEST_KIND_BASE,
   JOB_RESULT_KIND_BASE,
+  JOB_REVIEW_KIND,
   KmsIdentityError,
+  MINA_CHAIN_PRESETS,
   MOCK_USDC_ADDRESS,
   MOCK_USDC_CONFIG,
   NixBuilder,
   NostrPeerDiscovery,
+  PET_INTERACTION_EVENT_KIND,
+  PET_INTERACTION_REQUEST_KIND,
+  PET_INTERACTION_RESULT_KIND,
+  PREFIX_CLAIM_KIND,
+  PREFIX_GRANT_KIND,
   PcrReproducibilityError,
   PeerDiscoveryError,
+  ReputationScoreCalculator,
   SEED_RELAY_LIST_KIND,
   SERVICE_DISCOVERY_KIND,
+  SOLANA_CHAIN_PRESETS,
   SeedRelayDiscovery,
   SocialPeerDiscovery,
   TEE_ATTESTATION_KIND,
@@ -3465,16 +4753,33 @@ export {
   USDC_NAME,
   USDC_SYMBOL,
   VERSION,
+  WEB_OF_TRUST_KIND,
+  WORKFLOW_CHAIN_KIND,
   analyzeDockerfileForNonDeterminism,
+  assignAddressFromHandshake,
   buildAttestationEvent,
+  buildBlobStorageRequest,
   buildEip712Domain,
+  buildEvmProviderEntry,
   buildIlpPeerInfoEvent,
   buildIlpPrepare,
   buildJobFeedbackEvent,
   buildJobRequestEvent,
   buildJobResultEvent,
+  buildJobReviewEvent,
+  buildMinaProviderEntry,
+  buildPrefixClaimEvent,
+  buildPrefixGrantEvent,
+  buildPrefixHandshakeData,
   buildSeedRelayListEvent,
   buildServiceDiscoveryEvent,
+  buildSolanaProviderEntry,
+  buildSwarmRequestEvent,
+  buildSwarmSelectionEvent,
+  buildWorkflowDefinitionEvent,
+  buildWotDeclarationEvent,
+  calculateRouteAmount,
+  checkAddressCollision,
   createAgentRuntimeClient,
   createDirectChannelClient,
   createDirectConnectorAdmin,
@@ -3489,23 +4794,43 @@ export {
   createLogger,
   createToonNode,
   decodeEventFromToon,
+  deriveChildAddress,
   deriveFromKmsSeed,
   encodeEventToToon,
   encodeEventToToonString,
+  extractPrefixFromHandshake,
+  hasMinReputation,
+  hasRequireAttestation,
+  isGenesisNode,
+  isValidIlpAddressStructure,
   negotiateSettlementChain,
   parseAttestation,
+  parseBlobStorageRequest,
   parseIlpPeerInfo,
   parseJobFeedback,
   parseJobRequest,
   parseJobResult,
+  parseJobReview,
+  parsePrefixClaimEvent,
+  parsePrefixGrantEvent,
   parseSeedRelayList,
   parseServiceDiscovery,
+  parseSwarmRequest,
+  parseSwarmSelection,
+  parseWorkflowDefinition,
+  parseWotDeclaration,
   publishSeedRelayEntry,
   readDockerfileNix,
   resolveChainConfig,
+  resolveMinaChainConfig,
+  resolveRouteFees,
+  resolveSolanaChainConfig,
   resolveTokenForChain,
   shallowParseToon,
   validateChainId,
+  validateIlpAddress,
+  validatePrefix,
+  validatePrefixConsistency,
   verifyPcrReproducibility
 };
 //# sourceMappingURL=index.js.map