@toon-protocol/sdk 2.0.1 → 2.2.0

package/dist/{chunk-Z6S56VPV.js → chunk-RAZRWSJF.js}

@@ -520,6 +520,313 @@ function decryptFulfillClaim(params) {
   }
 }
 
+// src/stream-receipts.ts
+import { schnorr } from "@noble/curves/secp256k1.js";
+import { sha256 } from "@noble/hashes/sha2.js";
+import { bytesToHex as bytesToHex2, hexToBytes } from "@noble/hashes/utils.js";
+var STREAM_RECEIPT_VERSION = 1;
+var STREAM_RECEIPT_SIGNING_TAG = "toon.stream-receipt.v1";
+var STREAM_NONCE_REGEX = /^[0-9a-f]{32}$/;
+var SIG_REGEX = /^[0-9a-f]{128}$/;
+var HEX64_REGEX = /^[0-9a-f]{64}$/;
+var DECIMAL_UINT_REGEX = /^(0|[1-9]\d*)$/;
+var RATE_REGEX = /^(0|[1-9]\d*)(\.\d+)?$/;
+function isValidStreamNonce(value) {
+  return typeof value === "string" && STREAM_NONCE_REGEX.test(value);
+}
+function parseStreamReceipt(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("receipt must be an object");
+  }
+  const obj = value;
+  if (obj["v"] !== STREAM_RECEIPT_VERSION) {
+    throw new Error(
+      `receipt.v must be ${STREAM_RECEIPT_VERSION}, got ${String(obj["v"])}`
+    );
+  }
+  if (!isValidStreamNonce(obj["streamNonce"])) {
+    throw new Error("receipt.streamNonce must be 32-char lowercase hex");
+  }
+  const seq = obj["seq"];
+  if (typeof seq !== "number" || !Number.isSafeInteger(seq) || seq < 1) {
+    throw new Error("receipt.seq must be a positive safe integer");
+  }
+  const cumulativeDelivered = obj["cumulativeDelivered"];
+  if (typeof cumulativeDelivered !== "string" || !DECIMAL_UINT_REGEX.test(cumulativeDelivered)) {
+    throw new Error(
+      "receipt.cumulativeDelivered must be a non-negative integer decimal string"
+    );
+  }
+  const rate = obj["rate"];
+  if (typeof rate !== "string" || !RATE_REGEX.test(rate) || /^0(\.0+)?$/.test(rate)) {
+    throw new Error("receipt.rate must be a positive decimal string");
+  }
+  const rateTimestamp = obj["rateTimestamp"];
+  if (typeof rateTimestamp !== "number" || !Number.isInteger(rateTimestamp) || rateTimestamp <= 0) {
+    throw new Error(
+      "receipt.rateTimestamp must be a positive integer (unix ms)"
+    );
+  }
+  const sig = obj["sig"];
+  if (typeof sig !== "string" || !SIG_REGEX.test(sig)) {
+    throw new Error("receipt.sig must be 128-char lowercase hex");
+  }
+  return {
+    v: STREAM_RECEIPT_VERSION,
+    streamNonce: obj["streamNonce"],
+    seq,
+    cumulativeDelivered,
+    rate,
+    rateTimestamp,
+    sig
+  };
+}
+function encodeReceiptSigningPayload(fields) {
+  if (!isValidStreamNonce(fields.streamNonce)) {
+    throw new Error("streamNonce must be 32-char lowercase hex");
+  }
+  const tag = Buffer.from(STREAM_RECEIPT_SIGNING_TAG, "utf8");
+  const cumulative = Buffer.from(fields.cumulativeDelivered, "utf8");
+  const rate = Buffer.from(fields.rate, "utf8");
+  const buf = Buffer.alloc(
+    4 + tag.length + 1 + 16 + 8 + 4 + cumulative.length + 4 + rate.length + 8
+  );
+  let off = 0;
+  buf.writeUInt32BE(tag.length, off);
+  off += 4;
+  tag.copy(buf, off);
+  off += tag.length;
+  buf.writeUInt8(fields.v, off);
+  off += 1;
+  Buffer.from(hexToBytes(fields.streamNonce)).copy(buf, off);
+  off += 16;
+  buf.writeBigUInt64BE(BigInt(fields.seq), off);
+  off += 8;
+  buf.writeUInt32BE(cumulative.length, off);
+  off += 4;
+  cumulative.copy(buf, off);
+  off += cumulative.length;
+  buf.writeUInt32BE(rate.length, off);
+  off += 4;
+  rate.copy(buf, off);
+  off += rate.length;
+  buf.writeBigUInt64BE(BigInt(fields.rateTimestamp), off);
+  return new Uint8Array(buf);
+}
+function signStreamReceipt(fields, secretKey) {
+  if (!(secretKey instanceof Uint8Array) || secretKey.length !== 32) {
+    throw new Error("receipt secretKey must be a 32-byte Uint8Array");
+  }
+  const digest = sha256(encodeReceiptSigningPayload(fields));
+  const sig = bytesToHex2(schnorr.sign(digest, secretKey));
+  return { ...fields, sig };
+}
+function verifyStreamReceipt(receipt, makerPubkey) {
+  if (typeof makerPubkey !== "string" || !HEX64_REGEX.test(makerPubkey)) {
+    return false;
+  }
+  if (typeof receipt.sig !== "string" || !SIG_REGEX.test(receipt.sig)) {
+    return false;
+  }
+  try {
+    const { sig: _sig, ...fields } = receipt;
+    const digest = sha256(encodeReceiptSigningPayload(fields));
+    return schnorr.verify(
+      hexToBytes(receipt.sig),
+      digest,
+      hexToBytes(makerPubkey)
+    );
+  } catch {
+    return false;
+  }
+}
+var ReceiptChainTracker = class {
+  #streamNonce;
+  #makerPubkey;
+  /** Verified receipts, kept sorted by ascending seq. */
+  #receipts = [];
+  #seqs = /* @__PURE__ */ new Set();
+  constructor(input) {
+    if (!isValidStreamNonce(input.streamNonce)) {
+      throw new Error("streamNonce must be 32-char lowercase hex");
+    }
+    if (typeof input.makerPubkey !== "string" || !HEX64_REGEX.test(input.makerPubkey)) {
+      throw new Error("makerPubkey must be a 64-char lowercase hex string");
+    }
+    this.#streamNonce = input.streamNonce;
+    this.#makerPubkey = input.makerPubkey;
+  }
+  get streamNonce() {
+    return this.#streamNonce;
+  }
+  /** Number of verified receipts accumulated so far. */
+  get size() {
+    return this.#receipts.length;
+  }
+  /**
+   * Verify + accumulate one receipt. On `{ok: false}` the receipt is NOT
+   * added and the chain is unchanged.
+   */
+  add(receipt) {
+    if (receipt.streamNonce !== this.#streamNonce) {
+      return {
+        ok: false,
+        code: "WRONG_STREAM_NONCE",
+        message: `receipt streamNonce ${receipt.streamNonce} does not match session ${this.#streamNonce}`
+      };
+    }
+    if (!verifyStreamReceipt(receipt, this.#makerPubkey)) {
+      return {
+        ok: false,
+        code: "BAD_SIGNATURE",
+        message: `receipt seq ${receipt.seq} signature does not verify against maker key ${this.#makerPubkey}`
+      };
+    }
+    if (this.#seqs.has(receipt.seq)) {
+      return {
+        ok: false,
+        code: "DUPLICATE_SEQ",
+        message: `duplicate receipt seq ${receipt.seq}`
+      };
+    }
+    let lo = 0;
+    let hi = this.#receipts.length;
+    while (lo < hi) {
+      const mid = lo + hi >>> 1;
+      const midReceipt = this.#receipts[mid];
+      if (midReceipt.seq < receipt.seq) lo = mid + 1;
+      else hi = mid;
+    }
+    const cumulative = BigInt(receipt.cumulativeDelivered);
+    const lower = lo > 0 ? this.#receipts[lo - 1] : void 0;
+    const higher = lo < this.#receipts.length ? this.#receipts[lo] : void 0;
+    if (lower && BigInt(lower.cumulativeDelivered) > cumulative) {
+      return {
+        ok: false,
+        code: "NON_MONOTONIC",
+        message: `receipt seq ${receipt.seq} cumulativeDelivered ${receipt.cumulativeDelivered} is below seq ${lower.seq}'s ${lower.cumulativeDelivered}`
+      };
+    }
+    if (higher && BigInt(higher.cumulativeDelivered) < cumulative) {
+      return {
+        ok: false,
+        code: "NON_MONOTONIC",
+        message: `receipt seq ${receipt.seq} cumulativeDelivered ${receipt.cumulativeDelivered} is above seq ${higher.seq}'s ${higher.cumulativeDelivered}`
+      };
+    }
+    this.#receipts.splice(lo, 0, receipt);
+    this.#seqs.add(receipt.seq);
+    return { ok: true };
+  }
+  /**
+   * Snapshot the accumulated chain: sorted receipts, the superseding latest,
+   * the signed total delivered, and any `seq` holes in `[1, latest.seq]`.
+   */
+  chain() {
+    const receipts = [...this.#receipts];
+    const latest = receipts[receipts.length - 1];
+    const holes = [];
+    if (latest) {
+      for (let seq = 1; seq <= latest.seq; seq++) {
+        if (!this.#seqs.has(seq)) holes.push(seq);
+      }
+    }
+    return {
+      streamNonce: this.#streamNonce,
+      receipts,
+      ...latest !== void 0 && { latest },
+      totalDelivered: latest?.cumulativeDelivered ?? "0",
+      holes
+    };
+  }
+};
+function serializeReceiptChain(chain) {
+  return JSON.stringify({
+    kind: "toon.stream-receipt-chain",
+    v: STREAM_RECEIPT_VERSION,
+    streamNonce: chain.streamNonce,
+    totalDelivered: chain.totalDelivered,
+    holes: chain.holes,
+    receipts: chain.receipts.map((r) => ({
+      v: r.v,
+      streamNonce: r.streamNonce,
+      seq: r.seq,
+      cumulativeDelivered: r.cumulativeDelivered,
+      rate: r.rate,
+      rateTimestamp: r.rateTimestamp,
+      sig: r.sig
+    }))
+  });
+}
+var DEFAULT_RECEIPT_SESSIONS_CAP = 1e4;
+var BoundedReceiptSessions = class {
+  #map = /* @__PURE__ */ new Map();
+  #cap;
+  constructor(cap = DEFAULT_RECEIPT_SESSIONS_CAP) {
+    if (!Number.isInteger(cap) || cap <= 0) {
+      throw new Error(
+        `BoundedReceiptSessions cap must be a positive integer, got ${cap}`
+      );
+    }
+    this.#cap = cap;
+  }
+  get size() {
+    return this.#map.size;
+  }
+  get cap() {
+    return this.#cap;
+  }
+  get(streamNonce) {
+    const state = this.#map.get(streamNonce);
+    if (state === void 0) return void 0;
+    this.#map.delete(streamNonce);
+    this.#map.set(streamNonce, state);
+    return state;
+  }
+  set(streamNonce, state) {
+    this.#map.delete(streamNonce);
+    this.#map.set(streamNonce, state);
+    while (this.#map.size > this.#cap) {
+      const first = this.#map.keys().next();
+      if (first.done) break;
+      this.#map.delete(first.value);
+    }
+    return this;
+  }
+  delete(streamNonce) {
+    return this.#map.delete(streamNonce);
+  }
+};
+function issueSessionReceipt(input) {
+  const { sessions, streamNonce, deliveredAmount, rate, rateTimestamp } = input;
+  if (deliveredAmount < 0n) {
+    throw new Error(
+      `deliveredAmount must be non-negative, got ${deliveredAmount}`
+    );
+  }
+  const prev = sessions.get(streamNonce) ?? {
+    seq: 0,
+    cumulativeDelivered: 0n
+  };
+  const next = {
+    seq: prev.seq + 1,
+    cumulativeDelivered: prev.cumulativeDelivered + deliveredAmount
+  };
+  const receipt = signStreamReceipt(
+    {
+      v: STREAM_RECEIPT_VERSION,
+      streamNonce,
+      seq: next.seq,
+      cumulativeDelivered: next.cumulativeDelivered.toString(),
+      rate,
+      rateTimestamp
+    },
+    input.secretKey
+  );
+  sessions.set(streamNonce, next);
+  return receipt;
+}
+
 // src/swap-handler.ts
 import { createHash } from "crypto";
 var DEFAULT_SEEN_PACKET_IDS_CAP = 1e4;
@@ -611,10 +918,10 @@ var BoundedSeenPacketIds = class {
     for (const k of this.#map.keys()) yield [k, k];
   }
 };
-var RATE_REGEX = /^(0|[1-9]\d*)(\.\d+)?$/;
+var RATE_REGEX2 = /^(0|[1-9]\d*)(\.\d+)?$/;
 function applyRate(params) {
   const { sourceAmount, fromScale, toScale, rate } = params;
-  if (!RATE_REGEX.test(rate)) {
+  if (!RATE_REGEX2.test(rate)) {
     throw new SwapHandlerError(`Invalid rate format: ${rate}`);
   }
   if (/^0(\.0+)?$/.test(rate)) {
@@ -713,7 +1020,12 @@ function createSwapHandler(config) {
       "claimIssuer must implement issueClaim(params): Promise<IssueClaimResult>"
     );
   }
+  if (config.receiptSecretKey !== void 0 && (!(config.receiptSecretKey instanceof Uint8Array) || config.receiptSecretKey.length !== 32)) {
+    throw new SwapHandlerError("receiptSecretKey must be a 32-byte Uint8Array");
+  }
   const logger = config.logger ?? NOOP_LOGGER;
+  const receiptSecretKey = config.receiptSecretKey ?? config.recipientSecretKey;
+  const receiptSessions = config.receiptSessions ?? new BoundedReceiptSessions();
   const seenPacketIds = config.seenPacketIds ?? new BoundedSeenPacketIds();
   return async (ctx) => {
     if (ctx.kind !== 1059) {
@@ -788,8 +1100,20 @@ function createSwapHandler(config) {
       seenPacketIds.delete(packetId);
     };
     let rate;
+    let rateTimestamp;
     try {
-      rate = config.rateProvider ? await config.rateProvider(pair) : pair.rate;
+      const provided = config.rateProvider ? await config.rateProvider(pair) : pair.rate;
+      if (typeof provided === "string") {
+        rate = provided;
+        rateTimestamp = Date.now();
+      } else if (provided !== null && typeof provided === "object" && typeof provided.rate === "string" && typeof provided.rateTimestamp === "number" && Number.isInteger(provided.rateTimestamp) && provided.rateTimestamp > 0) {
+        rate = provided.rate;
+        rateTimestamp = provided.rateTimestamp;
+      } else {
+        throw new SwapHandlerError(
+          "rateProvider must return a decimal-string rate or { rate, rateTimestamp }"
+        );
+      }
     } catch (err) {
       logger.error({
         event: "swap_handler.rate_provider_failed",
@@ -876,6 +1200,32 @@ function createSwapHandler(config) {
       releaseReservation();
       return ctx.reject("T00", "Internal error");
     }
+    let receipt;
+    const streamNonceTag = findTagValue(rumor, "stream-nonce");
+    if (streamNonceTag !== void 0) {
+      if (!isValidStreamNonce(streamNonceTag)) {
+        logger.warn({
+          event: "swap_handler.invalid_stream_nonce",
+          destination: ctx.destination
+        });
+      } else {
+        try {
+          receipt = issueSessionReceipt({
+            sessions: receiptSessions,
+            streamNonce: streamNonceTag,
+            deliveredAmount: targetAmount,
+            rate,
+            rateTimestamp,
+            secretKey: receiptSecretKey
+          });
+        } catch (err) {
+          logger.error({
+            event: "swap_handler.receipt_issue_failed",
+            error: err instanceof Error ? err.message : String(err)
+          });
+        }
+      }
+    }
     const claimBase64 = Buffer.from(ciphertext).toString("base64");
     logger.info({
       event: "swap_handler.claim_issued",
@@ -885,9 +1235,12 @@ function createSwapHandler(config) {
     const metadata = {
       claim: claimBase64,
       ephemeralPubkey,
-      targetAmount: targetAmount.toString()
+      targetAmount: targetAmount.toString(),
+      rate,
+      rateTimestamp
     };
     if (claimId !== void 0) metadata["claimId"] = claimId;
+    if (receipt !== void 0) metadata["receipt"] = receipt;
     if (settlementChannelId !== void 0 && settlementNonce !== void 0 && settlementCumulative !== void 0 && settlementRecipient !== void 0 && settlementSwapSigner !== void 0) {
       metadata["channelId"] = settlementChannelId;
       metadata["nonce"] = settlementNonce.toString();
@@ -914,8 +1267,8 @@ function computePacketId(senderPubkey, sourceAmount, rumor) {
 
 // src/stream-swap.ts
 import { getPublicKey as getPublicKey3 } from "nostr-tools/pure";
-var RATE_REGEX2 = /^(0|[1-9]\d*)(\.\d+)?$/;
-var HEX64_REGEX = /^[0-9a-f]{64}$/;
+var RATE_REGEX3 = /^(0|[1-9]\d*)(\.\d+)?$/;
+var HEX64_REGEX2 = /^[0-9a-f]{64}$/;
 var BASE64_REGEX = /^[A-Za-z0-9+/]+={0,2}$/;
 function isBase64(s) {
   if (s.length === 0 || s.length % 4 !== 0) return false;
@@ -951,26 +1304,29 @@ function buildSwapRumor(input) {
     totalPackets,
     nonce,
     createdAt,
-    chainRecipient
+    chainRecipient,
+    streamNonce
   } = input;
+  const tags = [
+    ["swap-from", `${pair.from.assetCode}:${pair.from.chain}`],
+    ["swap-to", `${pair.to.assetCode}:${pair.to.chain}`],
+    ["amount", sourceAmount.toString()],
+    ["seq", String(packetIndex), String(totalPackets)],
+    ["nonce", Buffer.from(nonce).toString("hex")],
+    ["chain-recipient", chainRecipient]
+  ];
+  if (streamNonce !== void 0) tags.push(["stream-nonce", streamNonce]);
   return {
     kind: 20032,
     pubkey: senderPubkey,
     content: "",
     created_at: createdAt,
-    tags: [
-      ["swap-from", `${pair.from.assetCode}:${pair.from.chain}`],
-      ["swap-to", `${pair.to.assetCode}:${pair.to.chain}`],
-      ["amount", sourceAmount.toString()],
-      ["seq", String(packetIndex), String(totalPackets)],
-      ["nonce", Buffer.from(nonce).toString("hex")],
-      ["chain-recipient", chainRecipient]
-    ]
+    tags
   };
 }
 var EVM_CHANNEL_ID_REGEX = /^0x[0-9a-f]{64}$/;
 var EVM_ADDRESS_REGEX = /^0x[0-9a-f]{40}$/;
-var DECIMAL_UINT_REGEX = /^(0|[1-9]\d*)$/;
+var DECIMAL_UINT_REGEX2 = /^(0|[1-9]\d*)$/;
 var BASE58_REGEX = /^[1-9A-HJ-NP-Za-km-z]+$/;
 function validateChainAddress(value, chain, kind) {
   if (chain.startsWith("evm:")) {
@@ -992,7 +1348,7 @@ function validateChainAddress(value, chain, kind) {
   }
   return value.length > 0;
 }
-function decodeFulfillMetadata(data, chain) {
+function decodeFulfillMetadata(data, chain, opts) {
   if (data === void 0 || data === null || data === "") {
     throw new StreamSwapError("FULFILL_DECODE_FAILED", "FULFILL data missing");
   }
@@ -1037,7 +1393,7 @@ function decodeFulfillMetadata(data, chain) {
       "FULFILL metadata.claim is missing or not base64 string"
     );
   }
-  if (typeof ephemeralPubkey !== "string" || !HEX64_REGEX.test(ephemeralPubkey)) {
+  if (typeof ephemeralPubkey !== "string" || !HEX64_REGEX2.test(ephemeralPubkey)) {
     throw new StreamSwapError(
       "FULFILL_DECODE_FAILED",
       "FULFILL metadata.ephemeralPubkey is missing or not 64-char hex"
@@ -1060,16 +1416,58 @@ function decodeFulfillMetadata(data, chain) {
     }
     result.targetAmount = ta;
   }
+  const tapeRate = obj["rate"];
+  const tapeTimestamp = obj["rateTimestamp"];
+  const hasRate = tapeRate !== void 0;
+  const hasTimestamp = tapeTimestamp !== void 0;
+  if (hasRate !== hasTimestamp) {
+    throw new StreamSwapError(
+      "FULFILL_DECODE_FAILED",
+      "FULFILL metadata quote tape is malformed: rate and rateTimestamp must travel together"
+    );
+  }
+  if (hasRate) {
+    if (typeof tapeRate !== "string" || !RATE_REGEX3.test(tapeRate) || /^0(\.0+)?$/.test(tapeRate)) {
+      throw new StreamSwapError(
+        "FULFILL_DECODE_FAILED",
+        "FULFILL metadata.rate must be a positive decimal string"
+      );
+    }
+    if (typeof tapeTimestamp !== "number" || !Number.isInteger(tapeTimestamp) || tapeTimestamp <= 0) {
+      throw new StreamSwapError(
+        "FULFILL_DECODE_FAILED",
+        "FULFILL metadata.rateTimestamp must be a positive integer (unix ms)"
+      );
+    }
+    result.rate = tapeRate;
+    result.rateTimestamp = tapeTimestamp;
+  } else if (opts?.requireQuoteTape === true) {
+    throw new StreamSwapError(
+      "FULFILL_DECODE_FAILED",
+      "FULFILL metadata is missing the quote tape (rate + rateTimestamp) required when minExchangeRate is set"
+    );
+  }
+  if (obj["receipt"] !== void 0) {
+    try {
+      result.receipt = parseStreamReceipt(obj["receipt"]);
+    } catch (err) {
+      throw new StreamSwapError(
+        "FULFILL_DECODE_FAILED",
+        `FULFILL metadata.receipt is malformed: ${err instanceof Error ? err.message : String(err)}`,
+        { cause: err }
+      );
+    }
+  }
   const channelId = obj["channelId"];
   if (typeof channelId === "string" && (!chain || validateChainAddress(channelId, chain, "channelId"))) {
     result.channelId = channelId;
   }
   const nonce = obj["nonce"];
-  if (typeof nonce === "string" && DECIMAL_UINT_REGEX.test(nonce)) {
+  if (typeof nonce === "string" && DECIMAL_UINT_REGEX2.test(nonce)) {
     result.nonce = nonce;
   }
   const cumulativeAmount = obj["cumulativeAmount"];
-  if (typeof cumulativeAmount === "string" && DECIMAL_UINT_REGEX.test(cumulativeAmount)) {
+  if (typeof cumulativeAmount === "string" && DECIMAL_UINT_REGEX2.test(cumulativeAmount)) {
     result.cumulativeAmount = cumulativeAmount;
   }
   const recipient = obj["recipient"];
@@ -1082,6 +1480,18 @@ function decodeFulfillMetadata(data, chain) {
   }
   return result;
 }
+function compareDecimalRates(a, b) {
+  const split = (s) => {
+    const dot = s.indexOf(".");
+    return dot === -1 ? { int: s, frac: "" } : { int: s.slice(0, dot), frac: s.slice(dot + 1) };
+  };
+  const pa = split(a);
+  const pb = split(b);
+  const scale = Math.max(pa.frac.length, pb.frac.length);
+  const av = BigInt(pa.int + pa.frac.padEnd(scale, "0"));
+  const bv = BigInt(pb.int + pb.frac.padEnd(scale, "0"));
+  return av < bv ? -1 : av > bv ? 1 : 0;
+}
 var Deferred = class {
   promise;
   resolve;
@@ -1110,13 +1520,25 @@ function validateParams(params) {
   }
   const hasCount = params.packetCount !== void 0;
   const hasAmounts = params.packetAmounts !== void 0;
-  if (hasCount === hasAmounts) {
+  const hasController = params.controller !== void 0;
+  const chunkingModes = [hasCount, hasAmounts, hasController].filter(
+    Boolean
+  ).length;
+  if (chunkingModes !== 1) {
     throw new StreamSwapError(
       "INVALID_CHUNKING",
-      "Exactly one of packetCount or packetAmounts must be provided"
+      "Exactly one of packetCount, packetAmounts, or controller must be provided"
     );
   }
-  if (hasCount) {
+  if (hasController) {
+    const c = params.controller;
+    if (typeof c.nextDelta !== "function" || typeof c.observe !== "function" || typeof c.window !== "number") {
+      throw new StreamSwapError(
+        "INVALID_STATE",
+        "controller must implement nextDelta(remaining), observe(observation), and window"
+      );
+    }
+  } else if (hasCount) {
     const c = params.packetCount;
     if (!Number.isInteger(c) || c <= 0) {
       throw new StreamSwapError(
@@ -1161,7 +1583,7 @@ function validateParams(params) {
       "senderSecretKey must be a 32-byte Uint8Array"
     );
   }
-  if (typeof params.swapPubkey !== "string" || !HEX64_REGEX.test(params.swapPubkey)) {
+  if (typeof params.swapPubkey !== "string" || !HEX64_REGEX2.test(params.swapPubkey)) {
     throw new StreamSwapError(
       "INVALID_STATE",
       "swapPubkey must be a 64-char lowercase hex string"
@@ -1182,10 +1604,10 @@ function validateParams(params) {
       "pair.to must have { assetCode: string, assetScale: number, chain: string }"
     );
   }
-  if (typeof params.pair.rate !== "string" || !RATE_REGEX2.test(params.pair.rate)) {
+  if (typeof params.pair.rate !== "string" || !RATE_REGEX3.test(params.pair.rate)) {
     throw new StreamSwapError(
       "INVALID_PAIR",
-      `pair.rate must match ${RATE_REGEX2}, got ${params.pair.rate}`
+      `pair.rate must match ${RATE_REGEX3}, got ${params.pair.rate}`
     );
   }
   try {
@@ -1208,6 +1630,34 @@ function validateParams(params) {
       `rateDeviationThreshold must be a non-negative finite number, got ${params.rateDeviationThreshold}`
     );
   }
+  if (params.minExchangeRate !== void 0) {
+    if (typeof params.minExchangeRate !== "string" || !RATE_REGEX3.test(params.minExchangeRate) || /^0(\.0+)?$/.test(params.minExchangeRate)) {
+      throw new StreamSwapError(
+        "INVALID_STATE",
+        `minExchangeRate must be a positive decimal string matching ${RATE_REGEX3}, got ${String(
+          params.minExchangeRate
+        )}`
+      );
+    }
+  }
+  if (params.receiptPubkey !== void 0 && (typeof params.receiptPubkey !== "string" || !HEX64_REGEX2.test(params.receiptPubkey))) {
+    throw new StreamSwapError(
+      "INVALID_STATE",
+      "receiptPubkey must be a 64-char lowercase hex string"
+    );
+  }
+  if (params.requireReceipts !== void 0 && typeof params.requireReceipts !== "boolean") {
+    throw new StreamSwapError(
+      "INVALID_STATE",
+      `requireReceipts must be a boolean, got ${String(params.requireReceipts)}`
+    );
+  }
+  if (params.packetExpiryMs !== void 0 && (typeof params.packetExpiryMs !== "number" || !Number.isInteger(params.packetExpiryMs) || params.packetExpiryMs <= 0)) {
+    throw new StreamSwapError(
+      "INVALID_STATE",
+      `packetExpiryMs must be a positive integer (ms), got ${params.packetExpiryMs}`
+    );
+  }
   if (typeof params.chainRecipient !== "string" || params.chainRecipient.length === 0) {
     throw new StreamSwapError(
       "INVALID_STATE",
@@ -1231,13 +1681,16 @@ async function streamSwap(params) {
 function streamSwapControlled(params) {
   validateParams(params);
   const logger = params.logger ?? NOOP_LOGGER2;
-  const schedule = params.packetAmounts ? [...params.packetAmounts] : chunkAmount(params.totalAmount, params.packetCount);
+  const schedule = params.packetAmounts ? [...params.packetAmounts] : params.packetCount !== void 0 ? chunkAmount(params.totalAmount, params.packetCount) : [];
   const frozenPair = Object.freeze({
     from: Object.freeze({ ...params.pair.from }),
     to: Object.freeze({ ...params.pair.to }),
     rate: params.pair.rate
   });
   const senderPubkey = getPublicKey3(params.senderSecretKey);
+  const streamNonceBytes = new Uint8Array(16);
+  getRandomValues(streamNonceBytes);
+  const streamNonce = Buffer.from(streamNonceBytes).toString("hex");
   let streamState = "running";
   let resumeDeferred = null;
   const controller = {
@@ -1274,30 +1727,367 @@ function streamSwapControlled(params) {
       return streamState;
     }
   };
-  const result = runLoop(
+  const getState = () => streamState;
+  const setState = (v) => {
+    streamState = v;
+  };
+  const waitForResumeOrStop = () => {
+    if (streamState !== "paused")
+      return Promise.resolve("resume");
+    if (!resumeDeferred) resumeDeferred = new Deferred();
+    return resumeDeferred.promise;
+  };
+  const result = params.controller ? runAdaptiveLoop(
+    params,
+    frozenPair,
+    senderPubkey,
+    streamNonce,
+    logger,
+    getState,
+    setState,
+    waitForResumeOrStop
+  ) : runLoop(
     params,
     frozenPair,
     schedule,
     senderPubkey,
+    streamNonce,
     logger,
-    () => streamState,
-    (v) => {
-      streamState = v;
-    },
-    () => {
-      if (streamState !== "paused") return Promise.resolve("resume");
-      if (!resumeDeferred) resumeDeferred = new Deferred();
-      return resumeDeferred.promise;
-    }
+    getState,
+    setState,
+    waitForResumeOrStop
   );
   return { result, controller };
 }
-async function runLoop(params, pair, schedule, senderPubkey, logger, getState, setState, waitForResumeOrStop) {
-  const claims = [];
-  const rejections = [];
-  const errors = [];
-  let cumulativeSource = 0n;
-  let cumulativeTarget = 0n;
+function buildAndWrapPacket(input) {
+  const {
+    params,
+    pair,
+    senderPubkey,
+    sourceAmount,
+    seq,
+    totalPackets,
+    streamNonce
+  } = input;
+  const nonce = new Uint8Array(16);
+  getRandomValues(nonce);
+  const rumor = buildSwapRumor({
+    senderPubkey,
+    pair,
+    sourceAmount,
+    packetIndex: seq,
+    totalPackets,
+    nonce,
+    createdAt: Math.floor(Date.now() / 1e3),
+    chainRecipient: params.chainRecipient,
+    streamNonce
+  });
+  const packetExpiresAt = params.packetExpiryMs !== void 0 ? new Date(Date.now() + params.packetExpiryMs) : void 0;
+  const wrapped = wrapSwapPacketToToon({
+    rumor,
+    senderSecretKey: params.senderSecretKey,
+    recipientPubkey: params.swapPubkey,
+    destination: params.swapIlpAddress,
+    amount: sourceAmount,
+    ...packetExpiresAt !== void 0 && { expiresAt: packetExpiresAt }
+  });
+  const toonData = new Uint8Array(
+    Buffer.from(wrapped.ilpPrepare.data, "base64")
+  );
+  return {
+    toonData,
+    ...packetExpiresAt !== void 0 && { packetExpiresAt }
+  };
+}
+async function processAcceptedPacket(ctx, args) {
+  const { params, pair, logger } = ctx;
+  const { packetIndex, totalForProgress, sourceAmount, data } = args;
+  let metadata;
+  try {
+    metadata = decodeFulfillMetadata(data, pair.to.chain, {
+      requireQuoteTape: params.minExchangeRate !== void 0
+    });
+  } catch (err) {
+    logger.error({
+      event: "stream_swap.fulfill_decode_failed",
+      packetIndex,
+      error: err instanceof Error ? err.message : String(err)
+    });
+    ctx.errors.push({
+      packetIndex,
+      cause: err instanceof Error ? err : new Error(String(err))
+    });
+    return { status: "error" };
+  }
+  const isEvmTarget = pair.to.chain.startsWith("evm:");
+  const recipientMatches = metadata.recipient === void 0 || (isEvmTarget ? metadata.recipient.toLowerCase() === params.chainRecipient.toLowerCase() : metadata.recipient === params.chainRecipient);
+  if (!recipientMatches) {
+    logger.warn({
+      event: "stream_swap.recipient_mismatch",
+      packetIndex,
+      expected: params.chainRecipient,
+      actual: metadata.recipient
+    });
+    ctx.rejections.push({
+      packetIndex,
+      sourceAmount,
+      code: "SWAP_RECIPIENT_MISMATCH",
+      message: `Swap echoed recipient ${metadata.recipient} but sender expected ${params.chainRecipient}`
+    });
+    return { status: "recipient-mismatch" };
+  }
+  if (params.minExchangeRate !== void 0) {
+    const tapeRate = metadata.rate;
+    const floorTargetAmount = applyRate({
+      sourceAmount,
+      fromScale: pair.from.assetScale,
+      toScale: pair.to.assetScale,
+      rate: params.minExchangeRate
+    });
+    const deliveredTargetAmount = metadata.targetAmount !== void 0 ? BigInt(metadata.targetAmount) : applyRate({
+      sourceAmount,
+      fromScale: pair.from.assetScale,
+      toScale: pair.to.assetScale,
+      rate: tapeRate
+    });
+    const tapeBelowFloor = compareDecimalRates(tapeRate, params.minExchangeRate) < 0;
+    if (tapeBelowFloor || deliveredTargetAmount < floorTargetAmount) {
+      logger.warn({
+        event: "stream_swap.below_floor",
+        packetIndex,
+        rate: tapeRate,
+        rateTimestamp: metadata.rateTimestamp,
+        minExchangeRate: params.minExchangeRate,
+        targetAmount: deliveredTargetAmount.toString(),
+        floorTargetAmount: floorTargetAmount.toString()
+      });
+      ctx.rejections.push({
+        packetIndex,
+        sourceAmount,
+        code: "BELOW_FLOOR",
+        message: `Packet fill below minExchangeRate floor: rate ${tapeRate}, targetAmount ${deliveredTargetAmount} < floor ${params.minExchangeRate} (${floorTargetAmount})`
+      });
+      return { status: "below-floor" };
+    }
+  }
+  let verifiedReceipt;
+  if (metadata.receipt !== void 0) {
+    const receipt = metadata.receipt;
+    let failure;
+    if (metadata.rate !== void 0 && receipt.rate !== metadata.rate) {
+      failure = `receipt.rate ${receipt.rate} does not match tape rate ${metadata.rate}`;
+    } else if (metadata.rateTimestamp !== void 0 && receipt.rateTimestamp !== metadata.rateTimestamp) {
+      failure = `receipt.rateTimestamp ${receipt.rateTimestamp} does not match tape rateTimestamp ${metadata.rateTimestamp}`;
+    } else {
+      const added = ctx.receiptTracker.add(receipt);
+      if (!added.ok) failure = `${added.code}: ${added.message}`;
+    }
+    if (failure !== void 0) {
+      logger.warn({
+        event: "stream_swap.receipt_invalid",
+        packetIndex,
+        seq: receipt.seq,
+        error: failure
+      });
+      ctx.rejections.push({
+        packetIndex,
+        sourceAmount,
+        code: "RECEIPT_INVALID",
+        message: `Stream receipt failed verification: ${failure}`
+      });
+      return { status: "receipt-invalid" };
+    }
+    verifiedReceipt = receipt;
+  } else if (params.requireReceipts === true) {
+    logger.warn({
+      event: "stream_swap.receipt_missing",
+      packetIndex
+    });
+    ctx.rejections.push({
+      packetIndex,
+      sourceAmount,
+      code: "RECEIPT_MISSING",
+      message: "FULFILL carried no stream receipt but requireReceipts is set (legacy maker without rfc-0039 receipt support?)"
+    });
+    return { status: "receipt-invalid" };
+  }
+  let claimBytes;
+  try {
+    const ciphertext = new Uint8Array(Buffer.from(metadata.claim, "base64"));
+    claimBytes = decryptFulfillClaim({
+      ciphertext,
+      ephemeralPubkey: metadata.ephemeralPubkey,
+      recipientSecretKey: params.senderSecretKey
+    });
+  } catch (err) {
+    logger.error({
+      event: "stream_swap.decrypt_failed",
+      packetIndex,
+      error: err instanceof Error ? err.message : String(err)
+    });
+    ctx.errors.push({
+      packetIndex,
+      cause: err instanceof Error ? err : new Error(String(err))
+    });
+    return { status: "error" };
+  }
+  if (claimBytes.length === 0) {
+    logger.warn({
+      event: "stream_swap.empty_claim_bytes",
+      packetIndex
+    });
+  }
+  const expectedTargetAmount = applyRate({
+    sourceAmount,
+    fromScale: pair.from.assetScale,
+    toScale: pair.to.assetScale,
+    rate: pair.rate
+  });
+  const targetAmount = metadata.targetAmount !== void 0 ? BigInt(metadata.targetAmount) : expectedTargetAmount;
+  let rateDeviation = 0;
+  if (expectedTargetAmount > 0n) {
+    const diff = targetAmount >= expectedTargetAmount ? targetAmount - expectedTargetAmount : expectedTargetAmount - targetAmount;
+    const scaled = diff * 1000000n / expectedTargetAmount;
+    rateDeviation = Number(scaled) / 1e6;
+  }
+  const advertisedRate = parseFloat(pair.rate);
+  let effectiveRate;
+  if (targetAmount === expectedTargetAmount) {
+    effectiveRate = advertisedRate;
+  } else {
+    const signedDeviation = targetAmount >= expectedTargetAmount ? rateDeviation : -rateDeviation;
+    effectiveRate = advertisedRate * (1 + signedDeviation);
+  }
+  if (!Number.isFinite(effectiveRate)) {
+    effectiveRate = advertisedRate;
+  }
+  ctx.cumulative.source += sourceAmount;
+  ctx.cumulative.target += targetAmount;
+  const accumulated = {
+    packetIndex,
+    sourceAmount,
+    targetAmount,
+    claimBytes,
+    swapEphemeralPubkey: metadata.ephemeralPubkey,
+    pair,
+    receivedAt: Date.now()
+  };
+  if (metadata.claimId !== void 0) accumulated.claimId = metadata.claimId;
+  if (metadata.channelId !== void 0)
+    accumulated.channelId = metadata.channelId;
+  if (metadata.nonce !== void 0) accumulated.nonce = metadata.nonce;
+  if (metadata.cumulativeAmount !== void 0)
+    accumulated.cumulativeAmount = metadata.cumulativeAmount;
+  if (metadata.recipient !== void 0)
+    accumulated.recipient = metadata.recipient;
+  if (metadata.swapSignerAddress !== void 0)
+    accumulated.swapSignerAddress = metadata.swapSignerAddress;
+  if (metadata.rate !== void 0) {
+    accumulated.rate = metadata.rate;
+    accumulated.rateTimestamp = metadata.rateTimestamp;
+  }
+  if (verifiedReceipt !== void 0) accumulated.receipt = verifiedReceipt;
+  ctx.claims.push(accumulated);
+  logger.debug({
+    event: "stream_swap.packet_accepted",
+    packetIndex,
+    sourceAmount: sourceAmount.toString(),
+    targetAmount: targetAmount.toString()
+  });
+  if (params.onPacket) {
+    const progress = Object.freeze({
+      index: packetIndex,
+      total: totalForProgress,
+      sourceAmount,
+      targetAmount,
+      advertisedRate: pair.rate,
+      effectiveRate,
+      rateDeviation,
+      cumulativeSource: ctx.cumulative.source,
+      cumulativeTarget: ctx.cumulative.target,
+      // Issue #82 quote tape: surface the maker's fresh per-packet quote
+      // to the callback (the adaptive-controller seam, toon#83).
+      ...metadata.rate !== void 0 && {
+        rate: metadata.rate,
+        rateTimestamp: metadata.rateTimestamp
+      },
+      // Issue #84: surface the verified per-fulfill receipt to the callback.
+      ...verifiedReceipt !== void 0 && { receipt: verifiedReceipt },
+      state: ctx.getState() === "paused" ? "paused" : ctx.getState() === "stopped" ? "stopped" : "running"
+    });
+    try {
+      const maybePromise = params.onPacket(progress);
+      if (maybePromise && typeof maybePromise.then === "function") {
+        await maybePromise;
+      }
+    } catch (err) {
+      logger.warn({
+        event: "stream_swap.callback_threw",
+        packetIndex,
+        error: err instanceof Error ? err.message : String(err)
+      });
+      ctx.errors.push({
+        packetIndex,
+        cause: err instanceof Error ? err : new Error(String(err))
+      });
+      return { status: "callback-throw" };
+    }
+  }
+  return {
+    status: "accepted",
+    targetAmount,
+    rateDeviation,
+    ...metadata.rate !== void 0 && {
+      rate: metadata.rate,
+      rateTimestamp: metadata.rateTimestamp
+    }
+  };
+}
+function finalizeResult(input) {
+  const { claims, rejections, errors, cumulative } = input.ctx;
+  let { abortReason } = input;
+  let finalState;
+  if (abortReason === "aborted" || abortReason === "stopped") {
+    finalState = "stopped";
+  } else if (claims.length === 0 && (rejections.length > 0 || errors.length > 0)) {
+    finalState = "failed";
+    if (abortReason === "complete" && rejections.length > 0 && errors.length === 0) {
+      abortReason = "all-rejected";
+    }
+  } else {
+    finalState = "completed";
+  }
+  input.setState(finalState);
+  return {
+    state: finalState,
+    claims,
+    rejections,
+    errors,
+    abortReason,
+    cumulativeSource: cumulative.source,
+    cumulativeTarget: cumulative.target,
+    packetsSent: input.packetsSent,
+    packetsScheduled: input.packetsScheduled,
+    // Issue #84: the verified receipt chain — present on abort too,
+    // covering exactly the packets that filled before the halt.
+    receipts: input.ctx.receiptTracker.chain()
+  };
+}
+async function runLoop(params, pair, schedule, senderPubkey, streamNonce, logger, getState, setState, waitForResumeOrStop) {
+  const ctx = {
+    params,
+    pair,
+    logger,
+    getState,
+    claims: [],
+    rejections: [],
+    errors: [],
+    cumulative: { source: 0n, target: 0n },
+    receiptTracker: new ReceiptChainTracker({
+      streamNonce,
+      makerPubkey: params.receiptPubkey ?? params.swapPubkey
+    })
+  };
   let packetsSent = 0;
   let abortReason = "complete";
   const totalPackets = schedule.length;
@@ -1329,40 +2119,30 @@ async function runLoop(params, pair, schedule, senderPubkey, logger, getState, s
         `schedule[${packetIndex}] is undefined; schedule was mutated mid-stream`
       );
     }
-    const nonce = new Uint8Array(16);
-    getRandomValues(nonce);
-    const rumor = buildSwapRumor({
-      senderPubkey,
-      pair,
-      sourceAmount,
-      packetIndex: packetIndex + 1,
-      totalPackets,
-      nonce,
-      createdAt: Math.floor(Date.now() / 1e3),
-      chainRecipient: params.chainRecipient
-    });
-    let toonData;
+    let built;
     try {
-      const wrapped = wrapSwapPacketToToon({
-        rumor,
-        senderSecretKey: params.senderSecretKey,
-        recipientPubkey: params.swapPubkey,
-        destination: params.swapIlpAddress,
-        amount: sourceAmount
+      built = buildAndWrapPacket({
+        params,
+        pair,
+        senderPubkey,
+        sourceAmount,
+        seq: packetIndex + 1,
+        totalPackets,
+        streamNonce
       });
-      toonData = new Uint8Array(Buffer.from(wrapped.ilpPrepare.data, "base64"));
     } catch (err) {
       logger.error({
         event: "stream_swap.wrap_failed",
         packetIndex,
         error: err instanceof Error ? err.message : String(err)
       });
-      errors.push({
+      ctx.errors.push({
         packetIndex,
         cause: err instanceof Error ? err : new Error(String(err))
       });
       continue;
     }
+    const { toonData, packetExpiresAt } = built;
     let sendResult;
     try {
       sendResult = await params.client.sendSwapPacket({
@@ -1370,7 +2150,8 @@ async function runLoop(params, pair, schedule, senderPubkey, logger, getState, s
         amount: sourceAmount,
         toonData,
         timeout: params.packetTimeoutMs ?? 3e4,
-        claim: params.claim
+        claim: params.claim,
+        ...packetExpiresAt !== void 0 && { expiresAt: packetExpiresAt }
       });
       packetsSent += 1;
     } catch (err) {
@@ -1379,7 +2160,7 @@ async function runLoop(params, pair, schedule, senderPubkey, logger, getState, s
         packetIndex,
         error: err instanceof Error ? err.message : String(err)
       });
-      errors.push({
+      ctx.errors.push({
         packetIndex,
         cause: err instanceof Error ? err : new Error(String(err))
       });
@@ -1394,187 +2175,307 @@ async function runLoop(params, pair, schedule, senderPubkey, logger, getState, s
         code,
         message
       });
-      rejections.push({ packetIndex, sourceAmount, code, message });
+      ctx.rejections.push({ packetIndex, sourceAmount, code, message });
+      continue;
+    }
+    const outcome = await processAcceptedPacket(ctx, {
+      packetIndex,
+      totalForProgress: totalPackets,
+      sourceAmount,
+      data: sendResult.data
+    });
+    if (outcome.status === "error" || outcome.status === "recipient-mismatch") {
       continue;
     }
-    let metadata;
+    if (outcome.status === "below-floor") {
+      abortReason = "below-floor";
+      break packetLoop;
+    }
+    if (outcome.status === "receipt-invalid") {
+      abortReason = "receipt-invalid";
+      break packetLoop;
+    }
+    if (outcome.status === "callback-throw") {
+      abortReason = "callback-throw";
+      break packetLoop;
+    }
+    if (isAborted()) {
+      abortReason = "aborted";
+      break;
+    }
+    if (getState() === "stopped") {
+      abortReason = "stopped";
+      break;
+    }
+    if (params.rateDeviationThreshold !== void 0 && outcome.rateDeviation > params.rateDeviationThreshold) {
+      abortReason = "rate-deviation";
+      break;
+    }
+  }
+  return finalizeResult({
+    ctx,
+    abortReason,
+    packetsSent,
+    packetsScheduled: totalPackets,
+    setState
+  });
+}
+function classifySendError(err) {
+  return /timeout|timed out|expire/i.test(err.message) ? "timeout" : "error";
+}
+function classifyReject(code, message) {
+  if (code === "T99" || /stale[_-]?rate/i.test(message)) return "reject-stale";
+  if (code.startsWith("R") || /timeout|timed out|expire/i.test(message)) {
+    return "timeout";
+  }
+  return "reject";
+}
+async function runAdaptiveLoop(params, pair, senderPubkey, streamNonce, logger, getState, setState, waitForResumeOrStop) {
+  const controller = params.controller;
+  const ctx = {
+    params,
+    pair,
+    logger,
+    getState,
+    claims: [],
+    rejections: [],
+    errors: [],
+    cumulative: { source: 0n, target: 0n },
+    receiptTracker: new ReceiptChainTracker({
+      streamNonce,
+      makerPubkey: params.receiptPubkey ?? params.swapPubkey
+    })
+  };
+  let packetsSent = 0;
+  let abortReason = "complete";
+  let halted = false;
+  let remaining = params.totalAmount;
+  let nextIndex = 0;
+  const isAborted = () => params.signal?.aborted === true;
+  const halt = (reason) => {
+    if (!halted) {
+      halted = true;
+      abortReason = reason;
+    }
+  };
+  const observeSafe = async (obs) => {
     try {
-      metadata = decodeFulfillMetadata(sendResult.data, pair.to.chain);
+      await controller.observe(obs);
     } catch (err) {
-      logger.error({
-        event: "stream_swap.fulfill_decode_failed",
-        packetIndex,
+      logger.warn({
+        event: "stream_swap.controller_observe_failed",
         error: err instanceof Error ? err.message : String(err)
       });
-      errors.push({
-        packetIndex,
-        cause: err instanceof Error ? err : new Error(String(err))
-      });
-      continue;
     }
-    const isEvmTarget = pair.to.chain.startsWith("evm:");
-    const recipientMatches = metadata.recipient === void 0 || (isEvmTarget ? metadata.recipient.toLowerCase() === params.chainRecipient.toLowerCase() : metadata.recipient === params.chainRecipient);
-    if (!recipientMatches) {
-      logger.warn({
-        event: "stream_swap.recipient_mismatch",
-        packetIndex,
-        expected: params.chainRecipient,
-        actual: metadata.recipient
-      });
-      rejections.push({
-        packetIndex,
-        sourceAmount,
-        code: "SWAP_RECIPIENT_MISMATCH",
-        message: `Swap echoed recipient ${metadata.recipient} but sender expected ${params.chainRecipient}`
-      });
-      continue;
+  };
+  const inflight = /* @__PURE__ */ new Map();
+  for (; ; ) {
+    if (!halted && isAborted()) halt("aborted");
+    if (!halted && getState() === "stopped") halt("stopped");
+    if (!halted && getState() === "paused" && inflight.size === 0) {
+      const resumedBy = await waitForResumeOrStop();
+      if (resumedBy === "stop" || getState() === "stopped") halt("stopped");
+      else if (isAborted()) halt("aborted");
+    }
+    if (!halted && getState() === "running") {
+      const rawWindow = controller.window;
+      const window = Number.isFinite(rawWindow) && rawWindow >= 1 ? Math.floor(rawWindow) : 1;
+      while (remaining > 0n && inflight.size < window) {
+        let delta;
+        try {
+          delta = controller.nextDelta(remaining);
+        } catch (err) {
+          logger.error({
+            event: "stream_swap.controller_next_delta_failed",
+            error: err instanceof Error ? err.message : String(err)
+          });
+          ctx.errors.push({
+            packetIndex: nextIndex,
+            cause: err instanceof Error ? err : new Error(String(err))
+          });
+          halt("callback-throw");
+          break;
+        }
+        if (typeof delta !== "bigint" || delta < 1n) delta = 1n;
+        if (delta > remaining) delta = remaining;
+        const packetIndex = nextIndex;
+        nextIndex += 1;
+        remaining -= delta;
+        let built;
+        try {
+          built = buildAndWrapPacket({
+            params,
+            pair,
+            senderPubkey,
+            sourceAmount: delta,
+            seq: packetIndex + 1,
+            // Adaptive mode: the final packet count is unknown upfront —
+            // `0` in the rumor's `seq` tag total position means "open".
+            totalPackets: 0,
+            streamNonce
+          });
+        } catch (err) {
+          logger.error({
+            event: "stream_swap.wrap_failed",
+            packetIndex,
+            error: err instanceof Error ? err.message : String(err)
+          });
+          ctx.errors.push({
+            packetIndex,
+            cause: err instanceof Error ? err : new Error(String(err))
+          });
+          continue;
+        }
+        const { toonData, packetExpiresAt } = built;
+        const sentAt = Date.now();
+        const promise = (async () => {
+          try {
+            const result = await params.client.sendSwapPacket({
+              destination: params.swapIlpAddress,
+              amount: delta,
+              toonData,
+              timeout: params.packetTimeoutMs ?? 3e4,
+              claim: params.claim,
+              ...packetExpiresAt !== void 0 && {
+                expiresAt: packetExpiresAt
+              }
+            });
+            return {
+              index: packetIndex,
+              sourceAmount: delta,
+              rttMs: Date.now() - sentAt,
+              result
+            };
+          } catch (err) {
+            return {
+              index: packetIndex,
+              sourceAmount: delta,
+              rttMs: Date.now() - sentAt,
+              error: err instanceof Error ? err : new Error(String(err))
+            };
+          }
+        })();
+        inflight.set(packetIndex, promise);
+      }
     }
-    let claimBytes;
-    try {
-      const ciphertext = new Uint8Array(Buffer.from(metadata.claim, "base64"));
-      claimBytes = decryptFulfillClaim({
-        ciphertext,
-        ephemeralPubkey: metadata.ephemeralPubkey,
-        recipientSecretKey: params.senderSecretKey
-      });
-    } catch (err) {
+    if (inflight.size === 0) {
+      if (halted || remaining <= 0n) break;
+      if (getState() === "paused") continue;
+      break;
+    }
+    const settled = await Promise.race(inflight.values());
+    inflight.delete(settled.index);
+    if (settled.error) {
       logger.error({
-        event: "stream_swap.decrypt_failed",
-        packetIndex,
-        error: err instanceof Error ? err.message : String(err)
+        event: "stream_swap.send_failed",
+        packetIndex: settled.index,
+        error: settled.error.message
       });
-      errors.push({
-        packetIndex,
-        cause: err instanceof Error ? err : new Error(String(err))
+      ctx.errors.push({ packetIndex: settled.index, cause: settled.error });
+      await observeSafe({
+        resolution: classifySendError(settled.error),
+        rttMs: settled.rttMs,
+        remaining
       });
       continue;
     }
-    if (claimBytes.length === 0) {
+    packetsSent += 1;
+    const sendResult = settled.result;
+    if (!sendResult.accepted) {
+      const code = sendResult.code ?? "F00";
+      const message = sendResult.message ?? "rejected";
       logger.warn({
-        event: "stream_swap.empty_claim_bytes",
-        packetIndex
+        event: "stream_swap.packet_rejected",
+        packetIndex: settled.index,
+        code,
+        message
       });
+      ctx.rejections.push({
+        packetIndex: settled.index,
+        sourceAmount: settled.sourceAmount,
+        code,
+        message
+      });
+      await observeSafe({
+        resolution: classifyReject(code, message),
+        rttMs: settled.rttMs,
+        remaining
+      });
+      continue;
     }
-    const expectedTargetAmount = applyRate({
-      sourceAmount,
-      fromScale: pair.from.assetScale,
-      toScale: pair.to.assetScale,
-      rate: pair.rate
-    });
-    const targetAmount = metadata.targetAmount !== void 0 ? BigInt(metadata.targetAmount) : expectedTargetAmount;
-    let rateDeviation = 0;
-    if (expectedTargetAmount > 0n) {
-      const diff = targetAmount >= expectedTargetAmount ? targetAmount - expectedTargetAmount : expectedTargetAmount - targetAmount;
-      const scaled = diff * 1000000n / expectedTargetAmount;
-      rateDeviation = Number(scaled) / 1e6;
-    }
-    const advertisedRate = parseFloat(pair.rate);
-    let effectiveRate;
-    if (targetAmount === expectedTargetAmount) {
-      effectiveRate = advertisedRate;
-    } else {
-      const signedDeviation = targetAmount >= expectedTargetAmount ? rateDeviation : -rateDeviation;
-      effectiveRate = advertisedRate * (1 + signedDeviation);
-    }
-    if (!Number.isFinite(effectiveRate)) {
-      effectiveRate = advertisedRate;
-    }
-    cumulativeSource += sourceAmount;
-    cumulativeTarget += targetAmount;
-    const accumulated = {
-      packetIndex,
-      sourceAmount,
-      targetAmount,
-      claimBytes,
-      swapEphemeralPubkey: metadata.ephemeralPubkey,
-      pair,
-      receivedAt: Date.now()
-    };
-    if (metadata.claimId !== void 0) accumulated.claimId = metadata.claimId;
-    if (metadata.channelId !== void 0)
-      accumulated.channelId = metadata.channelId;
-    if (metadata.nonce !== void 0) accumulated.nonce = metadata.nonce;
-    if (metadata.cumulativeAmount !== void 0)
-      accumulated.cumulativeAmount = metadata.cumulativeAmount;
-    if (metadata.recipient !== void 0)
-      accumulated.recipient = metadata.recipient;
-    if (metadata.swapSignerAddress !== void 0)
-      accumulated.swapSignerAddress = metadata.swapSignerAddress;
-    claims.push(accumulated);
-    logger.debug({
-      event: "stream_swap.packet_accepted",
-      packetIndex,
-      sourceAmount: sourceAmount.toString(),
-      targetAmount: targetAmount.toString()
+    const outcome = await processAcceptedPacket(ctx, {
+      packetIndex: settled.index,
+      totalForProgress: nextIndex,
+      sourceAmount: settled.sourceAmount,
+      data: sendResult.data
     });
-    if (params.onPacket) {
-      const progress = Object.freeze({
-        index: packetIndex,
-        total: totalPackets,
-        sourceAmount,
-        targetAmount,
-        advertisedRate: pair.rate,
-        effectiveRate,
-        rateDeviation,
-        cumulativeSource,
-        cumulativeTarget,
-        state: getState() === "paused" ? "paused" : getState() === "stopped" ? "stopped" : "running"
-      });
-      try {
-        const maybePromise = params.onPacket(progress);
-        if (maybePromise && typeof maybePromise.then === "function") {
-          await maybePromise;
-        }
-      } catch (err) {
-        logger.warn({
-          event: "stream_swap.callback_threw",
-          packetIndex,
-          error: err instanceof Error ? err.message : String(err)
+    switch (outcome.status) {
+      case "error":
+        await observeSafe({
+          resolution: "error",
+          rttMs: settled.rttMs,
+          remaining
         });
-        errors.push({
-          packetIndex,
-          cause: err instanceof Error ? err : new Error(String(err))
+        break;
+      case "recipient-mismatch":
+        await observeSafe({
+          resolution: "reject",
+          rttMs: settled.rttMs,
+          remaining
+        });
+        break;
+      case "below-floor":
+        await observeSafe({
+          resolution: "reject",
+          rttMs: settled.rttMs,
+          remaining
         });
-        abortReason = "callback-throw";
-        break packetLoop;
+        halt("below-floor");
+        break;
+      case "receipt-invalid":
+        await observeSafe({
+          resolution: "reject",
+          rttMs: settled.rttMs,
+          remaining
+        });
+        halt("receipt-invalid");
+        break;
+      case "callback-throw":
+        await observeSafe({
+          resolution: "fulfill",
+          rttMs: settled.rttMs,
+          remaining
+        });
+        halt("callback-throw");
+        break;
+      case "accepted": {
+        await observeSafe({
+          resolution: "fulfill",
+          rttMs: settled.rttMs,
+          remaining,
+          sourceAmount: settled.sourceAmount,
+          targetAmount: outcome.targetAmount,
+          ...outcome.rate !== void 0 && {
+            rate: outcome.rate,
+            rateTimestamp: outcome.rateTimestamp
+          }
+        });
+        if (isAborted()) halt("aborted");
+        else if (getState() === "stopped") halt("stopped");
+        else if (params.rateDeviationThreshold !== void 0 && outcome.rateDeviation > params.rateDeviationThreshold) {
+          halt("rate-deviation");
+        }
+        break;
       }
     }
-    if (isAborted()) {
-      abortReason = "aborted";
-      break;
-    }
-    if (getState() === "stopped") {
-      abortReason = "stopped";
-      break;
-    }
-    if (params.rateDeviationThreshold !== void 0 && rateDeviation > params.rateDeviationThreshold) {
-      abortReason = "rate-deviation";
-      break;
-    }
   }
-  let finalState;
-  if (abortReason === "aborted" || abortReason === "stopped") {
-    finalState = "stopped";
-  } else if (claims.length === 0 && (rejections.length > 0 || errors.length > 0)) {
-    finalState = "failed";
-    if (abortReason === "complete" && rejections.length > 0 && errors.length === 0) {
-      abortReason = "all-rejected";
-    }
-  } else {
-    finalState = "completed";
-  }
-  setState(finalState);
-  return {
-    state: finalState,
-    claims,
-    rejections,
-    errors,
+  return finalizeResult({
+    ctx,
     abortReason,
-    cumulativeSource,
-    cumulativeTarget,
     packetsSent,
-    packetsScheduled: totalPackets
-  };
+    packetsScheduled: nextIndex,
+    setState
+  });
 }
 function getRandomValues(buf) {
   const g = globalThis;
@@ -1599,7 +2500,8 @@ function getRandomValues(buf) {
 var __testing = {
   chunkAmount,
   decodeFulfillMetadata,
-  buildSwapRumor
+  buildSwapRumor,
+  compareDecimalRates
 };
 
 export {
@@ -1625,6 +2527,18 @@ export {
   unwrapSwapPacketFromToon,
   encryptFulfillClaim,
   decryptFulfillClaim,
+  STREAM_RECEIPT_VERSION,
+  STREAM_RECEIPT_SIGNING_TAG,
+  isValidStreamNonce,
+  parseStreamReceipt,
+  encodeReceiptSigningPayload,
+  signStreamReceipt,
+  verifyStreamReceipt,
+  ReceiptChainTracker,
+  serializeReceiptChain,
+  DEFAULT_RECEIPT_SESSIONS_CAP,
+  BoundedReceiptSessions,
+  issueSessionReceipt,
   SWAP_HANDLER_REJECT_CODES,
   SWAP_HANDLER_REJECT_MESSAGES,
   applyRate,
@@ -1634,4 +2548,4 @@ export {
   streamSwapControlled,
   __testing
 };
-//# sourceMappingURL=chunk-Z6S56VPV.js.map
+//# sourceMappingURL=chunk-RAZRWSJF.js.map