@toon-protocol/sdk 2.0.1 → 2.1.0

package/dist/{chunk-Z6S56VPV.js → chunk-7LBYFU4L.js}

@@ -788,8 +788,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",
@@ -885,7 +897,9 @@ function createSwapHandler(config) {
     const metadata = {
       claim: claimBase64,
       ephemeralPubkey,
-      targetAmount: targetAmount.toString()
+      targetAmount: targetAmount.toString(),
+      rate,
+      rateTimestamp
     };
     if (claimId !== void 0) metadata["claimId"] = claimId;
     if (settlementChannelId !== void 0 && settlementNonce !== void 0 && settlementCumulative !== void 0 && settlementRecipient !== void 0 && settlementSwapSigner !== void 0) {
@@ -992,7 +1006,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");
   }
@@ -1060,6 +1074,37 @@ 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_REGEX2.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"
+    );
+  }
   const channelId = obj["channelId"];
   if (typeof channelId === "string" && (!chain || validateChainAddress(channelId, chain, "channelId"))) {
     result.channelId = channelId;
@@ -1082,6 +1127,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 +1167,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(
@@ -1208,6 +1277,22 @@ 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_REGEX2.test(params.minExchangeRate) || /^0(\.0+)?$/.test(params.minExchangeRate)) {
+      throw new StreamSwapError(
+        "INVALID_STATE",
+        `minExchangeRate must be a positive decimal string matching ${RATE_REGEX2}, got ${String(
+          params.minExchangeRate
+        )}`
+      );
+    }
+  }
+  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,7 +1316,7 @@ 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 }),
@@ -1274,30 +1359,305 @@ 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,
+    logger,
+    getState,
+    setState,
+    waitForResumeOrStop
+  ) : runLoop(
     params,
     frozenPair,
     schedule,
     senderPubkey,
     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 };
 }
+function buildAndWrapPacket(input) {
+  const { params, pair, senderPubkey, sourceAmount, seq, totalPackets } = 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
+  });
+  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 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;
+  }
+  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
+      },
+      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
+  };
+}
 async function runLoop(params, pair, schedule, senderPubkey, logger, getState, setState, waitForResumeOrStop) {
-  const claims = [];
-  const rejections = [];
-  const errors = [];
-  let cumulativeSource = 0n;
-  let cumulativeTarget = 0n;
+  const ctx = {
+    params,
+    pair,
+    logger,
+    getState,
+    claims: [],
+    rejections: [],
+    errors: [],
+    cumulative: { source: 0n, target: 0n }
+  };
   let packetsSent = 0;
   let abortReason = "complete";
   const totalPackets = schedule.length;
@@ -1329,40 +1689,29 @@ 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
       });
-      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 +1719,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 +1729,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 +1744,290 @@ 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 === "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, logger, getState, setState, waitForResumeOrStop) {
+  const controller = params.controller;
+  const ctx = {
+    params,
+    pair,
+    logger,
+    getState,
+    claims: [],
+    rejections: [],
+    errors: [],
+    cumulative: { source: 0n, target: 0n }
+  };
+  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
+          });
+        } 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
+        });
+        break;
+      case "recipient-mismatch":
+        await observeSafe({
+          resolution: "reject",
+          rttMs: settled.rttMs,
+          remaining
+        });
+        break;
+      case "below-floor":
+        await observeSafe({
+          resolution: "reject",
+          rttMs: settled.rttMs,
+          remaining
         });
-        errors.push({
-          packetIndex,
-          cause: err instanceof Error ? err : new Error(String(err))
+        halt("below-floor");
+        break;
+      case "callback-throw":
+        await observeSafe({
+          resolution: "fulfill",
+          rttMs: settled.rttMs,
+          remaining
         });
-        abortReason = "callback-throw";
-        break packetLoop;
+        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 +2052,8 @@ function getRandomValues(buf) {
 var __testing = {
   chunkAmount,
   decodeFulfillMetadata,
-  buildSwapRumor
+  buildSwapRumor,
+  compareDecimalRates
 };
 
 export {
@@ -1634,4 +2088,4 @@ export {
   streamSwapControlled,
   __testing
 };
-//# sourceMappingURL=chunk-Z6S56VPV.js.map
+//# sourceMappingURL=chunk-7LBYFU4L.js.map