@toon-protocol/sdk 0.5.0 → 0.6.0

package/dist/chunk-XTHUXP63.js

@@ -0,0 +1,1637 @@
+import {
+  __require
+} from "./chunk-UP2VWCW5.js";
+
+// src/errors.ts
+import { ToonError } from "@toon-protocol/core";
+var IdentityError = class extends ToonError {
+  constructor(message, cause) {
+    super(message, "IDENTITY_ERROR", cause);
+    this.name = "IdentityError";
+  }
+};
+var NodeError = class extends ToonError {
+  constructor(message, cause) {
+    super(message, "NODE_ERROR", cause);
+    this.name = "NodeError";
+  }
+};
+var HandlerError = class extends ToonError {
+  constructor(message, cause) {
+    super(message, "HANDLER_ERROR", cause);
+    this.name = "HandlerError";
+  }
+};
+var VerificationError = class extends ToonError {
+  constructor(message, cause) {
+    super(message, "VERIFICATION_ERROR", cause);
+    this.name = "VerificationError";
+  }
+};
+var PricingError = class extends ToonError {
+  constructor(message, cause) {
+    super(message, "PRICING_ERROR", cause);
+    this.name = "PricingError";
+  }
+};
+var GiftWrapError = class extends ToonError {
+  constructor(message, cause) {
+    super(message, "GIFT_WRAP_ERROR", cause);
+    this.name = "GiftWrapError";
+  }
+};
+var SwapHandlerError = class extends ToonError {
+  constructor(message, cause) {
+    super(message, "SWAP_HANDLER_ERROR", cause);
+    this.name = "SwapHandlerError";
+  }
+};
+var StreamSwapError = class extends Error {
+  code;
+  constructor(code, message, options) {
+    super(message);
+    this.name = "StreamSwapError";
+    this.code = code;
+    if (options && "cause" in options) {
+      Object.defineProperty(this, "cause", {
+        value: options.cause,
+        enumerable: false,
+        writable: true,
+        configurable: true
+      });
+    }
+  }
+};
+var SettlementTxError = class extends Error {
+  code;
+  constructor(code, message, options) {
+    super(message);
+    this.name = "SettlementTxError";
+    this.code = code;
+    if (options && "cause" in options) {
+      Object.defineProperty(this, "cause", {
+        value: options.cause,
+        enumerable: false,
+        writable: true,
+        configurable: true
+      });
+    }
+  }
+};
+
+// src/identity.ts
+import {
+  generateMnemonic as _generateMnemonic,
+  validateMnemonic,
+  mnemonicToSeedSync
+} from "@scure/bip39";
+import { wordlist } from "@scure/bip39/wordlists/english.js";
+import { HDKey } from "@scure/bip32";
+import { getPublicKey } from "nostr-tools/pure";
+import { secp256k1 } from "@noble/curves/secp256k1.js";
+import { ed25519 } from "@noble/curves/ed25519.js";
+import { keccak_256 } from "@noble/hashes/sha3.js";
+import { hmac } from "@noble/hashes/hmac.js";
+import { sha512 } from "@noble/hashes/sha2.js";
+import { bytesToHex } from "@noble/hashes/utils.js";
+import { hexToMinaBase58PrivateKey } from "@toon-protocol/core";
+function generateMnemonic() {
+  return _generateMnemonic(wordlist, 128);
+}
+function fromMnemonic(mnemonic, options) {
+  if (!validateMnemonic(mnemonic, wordlist)) {
+    throw new IdentityError(
+      `Invalid BIP-39 mnemonic: the provided words do not form a valid mnemonic phrase`
+    );
+  }
+  const accountIndex = options?.accountIndex ?? 0;
+  if (!Number.isInteger(accountIndex) || accountIndex < 0 || accountIndex > MAX_BIP32_INDEX) {
+    throw new IdentityError(
+      `Invalid accountIndex: expected a non-negative integer (0 to ${MAX_BIP32_INDEX}), got ${String(accountIndex)}`
+    );
+  }
+  const path = `m/44'/1237'/0'/0/${accountIndex}`;
+  let seed;
+  try {
+    seed = mnemonicToSeedSync(mnemonic);
+    const hdKey = HDKey.fromMasterSeed(seed).derive(path);
+    if (!hdKey.privateKey) {
+      throw new IdentityError(`Failed to derive private key at path ${path}`);
+    }
+    const secretKey = hdKey.privateKey;
+    const base = deriveIdentity(secretKey);
+    const solana = deriveSolanaIdentity(seed, accountIndex);
+    return { ...base, solana };
+  } catch (error) {
+    if (error instanceof IdentityError) {
+      throw error;
+    }
+    throw new IdentityError(
+      `Key derivation failed at path ${path}: ${error instanceof Error ? error.message : String(error)}`,
+      error instanceof Error ? error : void 0
+    );
+  } finally {
+    if (seed) {
+      seed.fill(0);
+    }
+  }
+}
+function fromSecretKey(secretKey) {
+  if (!(secretKey instanceof Uint8Array)) {
+    throw new IdentityError(
+      `Invalid secret key: expected Uint8Array, got ${secretKey === null ? "null" : typeof secretKey}`
+    );
+  }
+  if (secretKey.length !== 32) {
+    throw new IdentityError(
+      `Invalid secret key: expected 32 bytes, got ${secretKey.length} bytes`
+    );
+  }
+  try {
+    return deriveIdentity(secretKey);
+  } catch (error) {
+    if (error instanceof IdentityError) {
+      throw error;
+    }
+    throw new IdentityError(
+      `Invalid secret key: ${error instanceof Error ? error.message : String(error)}`,
+      error instanceof Error ? error : void 0
+    );
+  }
+}
+var MAX_BIP32_INDEX = 2147483647;
+function deriveIdentity(secretKey) {
+  const pubkey = getPublicKey(secretKey);
+  const evmAddress = computeEvmAddress(secretKey);
+  return { secretKey: new Uint8Array(secretKey), pubkey, evmAddress };
+}
+function computeEvmAddress(secretKey) {
+  const uncompressedPubkey = secp256k1.getPublicKey(secretKey, false);
+  const pubkeyWithoutPrefix = uncompressedPubkey.slice(1);
+  const hash = keccak_256(pubkeyWithoutPrefix);
+  const addressBytes = hash.slice(-20);
+  const addressHex = bytesToHex(addressBytes);
+  return toChecksumAddress(addressHex);
+}
+function toChecksumAddress(addressHex) {
+  const lower = addressHex.toLowerCase();
+  const hash = bytesToHex(keccak_256(new TextEncoder().encode(lower)));
+  let checksummed = "0x";
+  for (let i = 0; i < 40; i++) {
+    const char = lower[i];
+    const hashChar = hash[i];
+    if (char === void 0 || hashChar === void 0) {
+      throw new IdentityError(
+        `Unexpected undefined at index ${i} during checksum computation`
+      );
+    }
+    const hashNibble = parseInt(hashChar, 16);
+    checksummed += hashNibble >= 8 ? char.toUpperCase() : char;
+  }
+  return checksummed;
+}
+function slip0010Derive(seed, path) {
+  const encoder = new TextEncoder();
+  let I = hmac(sha512, encoder.encode("ed25519 seed"), seed);
+  let key = I.slice(0, 32);
+  let chainCode = I.slice(32);
+  for (const index of path) {
+    const data = new Uint8Array(37);
+    data[0] = 0;
+    data.set(key, 1);
+    data[33] = index >>> 24 & 255;
+    data[34] = index >>> 16 & 255;
+    data[35] = index >>> 8 & 255;
+    data[36] = index & 255;
+    I = hmac(sha512, chainCode, data);
+    key = I.slice(0, 32);
+    chainCode = I.slice(32);
+  }
+  return key;
+}
+function solanaPath(accountIndex) {
+  return [
+    2147483692,
+    // 44'
+    2147484149,
+    // 501'
+    2147483648 + accountIndex >>> 0,
+    // {accountIndex}'
+    2147483648
+    // 0'
+  ];
+}
+function deriveSolanaIdentity(seed, accountIndex = 0) {
+  const privateKey = slip0010Derive(seed, solanaPath(accountIndex));
+  const publicKeyBytes = ed25519.getPublicKey(privateKey);
+  const keypair = new Uint8Array(64);
+  keypair.set(privateKey, 0);
+  keypair.set(publicKeyBytes, 32);
+  return { secretKey: keypair, publicKey: base58Encode(publicKeyBytes) };
+}
+async function deriveMinaIdentity(seed, accountIndex = 0) {
+  const path = `m/44'/12586'/${accountIndex}'/0/0`;
+  const hdKey = HDKey.fromMasterSeed(seed).derive(path);
+  if (!hdKey.privateKey) {
+    throw new IdentityError(
+      `Failed to derive Mina private key at path ${path}`
+    );
+  }
+  const keyBytes = new Uint8Array(hdKey.privateKey);
+  keyBytes[0] = (keyBytes[0] ?? 0) & 63;
+  const hexKey = bytesToHex(keyBytes);
+  try {
+    const MinaSignerLib = await import("mina-signer");
+    const Client = "default" in MinaSignerLib ? MinaSignerLib.default : MinaSignerLib;
+    const client = new Client({ network: "mainnet" });
+    const minaBase58PrivateKey = hexToMinaBase58PrivateKey(hexKey);
+    const publicKey = client.derivePublicKey(minaBase58PrivateKey);
+    return { privateKey: hexKey, publicKey };
+  } catch (err) {
+    const code = err?.code;
+    if (code === "ERR_MODULE_NOT_FOUND" || code === "MODULE_NOT_FOUND") {
+      return void 0;
+    }
+    throw new IdentityError(
+      `Mina identity derivation failed at path ${path}: ${err instanceof Error ? err.message : String(err)}`,
+      err instanceof Error ? err : void 0
+    );
+  }
+}
+async function fromMnemonicFull(mnemonic, options) {
+  const identity = fromMnemonic(mnemonic, options);
+  const accountIndex = options?.accountIndex ?? 0;
+  let seed;
+  try {
+    seed = mnemonicToSeedSync(mnemonic);
+    const mina = await deriveMinaIdentity(seed, accountIndex);
+    if (mina) {
+      return { ...identity, mina };
+    }
+  } finally {
+    if (seed) {
+      seed.fill(0);
+    }
+  }
+  return identity;
+}
+function generateSolanaKeypair() {
+  const privateKey = ed25519.utils.randomSecretKey();
+  const publicKeyBytes = ed25519.getPublicKey(privateKey);
+  const keypair = new Uint8Array(64);
+  keypair.set(privateKey, 0);
+  keypair.set(publicKeyBytes, 32);
+  return { secretKey: keypair, publicKey: base58Encode(publicKeyBytes) };
+}
+var BASE58_ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+function base58Encode(bytes) {
+  let zeros = 0;
+  for (let i = 0; i < bytes.length && bytes[i] === 0; i++) zeros++;
+  let value = 0n;
+  for (const byte of bytes) {
+    value = value * 256n + BigInt(byte);
+  }
+  let result = "";
+  while (value > 0n) {
+    result = BASE58_ALPHABET[Number(value % 58n)] + result;
+    value = value / 58n;
+  }
+  for (let i = 0; i < zeros; i++) {
+    result = "1" + result;
+  }
+  return result || "1";
+}
+function base58Decode(str) {
+  let zeros = 0;
+  for (let i = 0; i < str.length && str[i] === "1"; i++) zeros++;
+  let value = 0n;
+  for (const ch of str) {
+    const idx = BASE58_ALPHABET.indexOf(ch);
+    if (idx === -1) throw new IdentityError(`Invalid base58 character: ${ch}`);
+    value = value * 58n + BigInt(idx);
+  }
+  const hex = value === 0n ? "" : value.toString(16);
+  const hexPadded = hex.length % 2 ? "0" + hex : hex;
+  const rawBytes = [];
+  for (let i = 0; i < hexPadded.length; i += 2) {
+    rawBytes.push(parseInt(hexPadded.slice(i, i + 2), 16));
+  }
+  const result = new Uint8Array(zeros + rawBytes.length);
+  result.set(rawBytes, zeros);
+  return result;
+}
+
+// src/gift-wrap.ts
+import { generateSecretKey, getPublicKey as getPublicKey2 } from "nostr-tools/pure";
+import { createRumor, createSeal, createWrap } from "nostr-tools/nip59";
+import {
+  encrypt as nip44Encrypt,
+  decrypt as nip44Decrypt,
+  getConversationKey
+} from "nostr-tools/nip44";
+import {
+  encodeEventToToon,
+  decodeEventFromToon
+} from "@toon-protocol/core/toon";
+import { buildIlpPrepare } from "@toon-protocol/core";
+function validateSecretKey(key, paramName) {
+  if (!(key instanceof Uint8Array) || key.length !== 32) {
+    throw new GiftWrapError(
+      `${paramName} must be a 32-byte Uint8Array, got ${key instanceof Uint8Array ? `${key.length} bytes` : typeof key}`
+    );
+  }
+}
+function validatePubkey(pubkey, paramName) {
+  if (typeof pubkey !== "string" || !/^[0-9a-f]{64}$/.test(pubkey)) {
+    throw new GiftWrapError(
+      `${paramName} must be a 64-character lowercase hex string`
+    );
+  }
+}
+function wrapSwapPacket(params) {
+  const { rumor, senderSecretKey, recipientPubkey } = params;
+  validateSecretKey(senderSecretKey, "senderSecretKey");
+  validatePubkey(recipientPubkey, "recipientPubkey");
+  try {
+    const rumorEvent = createRumor(rumor, senderSecretKey);
+    const seal = createSeal(rumorEvent, senderSecretKey, recipientPubkey);
+    const giftWrap = createWrap(seal, recipientPubkey);
+    const ephemeralPubkey = giftWrap.pubkey;
+    return { giftWrap, ephemeralPubkey };
+  } catch (error) {
+    throw new GiftWrapError(
+      `Failed to wrap swap packet: ${error instanceof Error ? error.message : String(error)}`,
+      error instanceof Error ? error : void 0
+    );
+  }
+}
+function unwrapSwapPacket(params) {
+  const { giftWrap, recipientSecretKey } = params;
+  validateSecretKey(recipientSecretKey, "recipientSecretKey");
+  if (!giftWrap || typeof giftWrap !== "object") {
+    throw new GiftWrapError("giftWrap must be a non-null object");
+  }
+  if (giftWrap.kind !== 1059) {
+    throw new GiftWrapError("Expected kind:1059 gift wrap");
+  }
+  let conversationKey1 = null;
+  let conversationKey2 = null;
+  try {
+    conversationKey1 = getConversationKey(recipientSecretKey, giftWrap.pubkey);
+    const sealJson = nip44Decrypt(giftWrap.content, conversationKey1);
+    const seal = JSON.parse(sealJson);
+    if (seal.kind !== 13) {
+      throw new GiftWrapError(
+        `Expected kind:13 seal inside gift wrap, got kind:${seal.kind}`
+      );
+    }
+    const senderPubkey = seal.pubkey;
+    validatePubkey(senderPubkey, "seal.pubkey (sender identity)");
+    conversationKey2 = getConversationKey(recipientSecretKey, senderPubkey);
+    const rumorJson = nip44Decrypt(seal.content, conversationKey2);
+    const rumor = JSON.parse(rumorJson);
+    delete rumor.sig;
+    return { rumor, senderPubkey };
+  } catch (error) {
+    if (error instanceof GiftWrapError) {
+      throw error;
+    }
+    throw new GiftWrapError(
+      `Failed to unwrap swap packet: ${error instanceof Error ? error.message : String(error)}`,
+      error instanceof Error ? error : void 0
+    );
+  } finally {
+    if (conversationKey1) {
+      conversationKey1.fill(0);
+      conversationKey1 = null;
+    }
+    if (conversationKey2) {
+      conversationKey2.fill(0);
+      conversationKey2 = null;
+    }
+  }
+}
+function wrapSwapPacketToToon(params) {
+  const {
+    rumor,
+    senderSecretKey,
+    recipientPubkey,
+    destination,
+    amount,
+    expiresAt
+  } = params;
+  const { giftWrap, ephemeralPubkey } = wrapSwapPacket({
+    rumor,
+    senderSecretKey,
+    recipientPubkey
+  });
+  const toonBinary = encodeEventToToon(giftWrap);
+  const ilpPrepare = buildIlpPrepare({
+    destination,
+    amount,
+    data: toonBinary,
+    expiresAt
+  });
+  return { ilpPrepare, ephemeralPubkey };
+}
+function unwrapSwapPacketFromToon(params) {
+  const { toonData, recipientSecretKey } = params;
+  if (!(toonData instanceof Uint8Array) || toonData.length === 0) {
+    throw new GiftWrapError("toonData must be a non-empty Uint8Array");
+  }
+  try {
+    const giftWrap = decodeEventFromToon(toonData);
+    return unwrapSwapPacket({ giftWrap, recipientSecretKey });
+  } catch (error) {
+    if (error instanceof GiftWrapError) {
+      throw error;
+    }
+    throw new GiftWrapError(
+      `Failed to unwrap swap packet from TOON: ${error instanceof Error ? error.message : String(error)}`,
+      error instanceof Error ? error : void 0
+    );
+  }
+}
+function encryptFulfillClaim(params) {
+  const { claimData, senderPubkey } = params;
+  validatePubkey(senderPubkey, "senderPubkey");
+  if (!(claimData instanceof Uint8Array)) {
+    throw new GiftWrapError(
+      `claimData must be a Uint8Array, got ${typeof claimData}`
+    );
+  }
+  if (claimData.length === 0) {
+    throw new GiftWrapError("claimData must not be empty");
+  }
+  let ephemeralSecretKey = generateSecretKey();
+  const ephemeralPubkey = getPublicKey2(ephemeralSecretKey);
+  let conversationKey = null;
+  try {
+    conversationKey = getConversationKey(ephemeralSecretKey, senderPubkey);
+    const claimString = Buffer.from(claimData).toString("base64");
+    const ciphertextString = nip44Encrypt(claimString, conversationKey);
+    const ciphertext = new TextEncoder().encode(ciphertextString);
+    return { ciphertext, ephemeralPubkey };
+  } catch (error) {
+    if (error instanceof GiftWrapError) {
+      throw error;
+    }
+    throw new GiftWrapError(
+      `Failed to encrypt FULFILL claim: ${error instanceof Error ? error.message : String(error)}`,
+      error instanceof Error ? error : void 0
+    );
+  } finally {
+    if (ephemeralSecretKey) {
+      ephemeralSecretKey.fill(0);
+      ephemeralSecretKey = null;
+    }
+    if (conversationKey) {
+      conversationKey.fill(0);
+      conversationKey = null;
+    }
+  }
+}
+function decryptFulfillClaim(params) {
+  const { ciphertext, ephemeralPubkey, recipientSecretKey } = params;
+  validateSecretKey(recipientSecretKey, "recipientSecretKey");
+  validatePubkey(ephemeralPubkey, "ephemeralPubkey");
+  if (!(ciphertext instanceof Uint8Array) || ciphertext.length === 0) {
+    throw new GiftWrapError("ciphertext must be a non-empty Uint8Array");
+  }
+  let conversationKey = null;
+  try {
+    conversationKey = getConversationKey(recipientSecretKey, ephemeralPubkey);
+    const ciphertextString = new TextDecoder().decode(ciphertext);
+    const claimString = nip44Decrypt(ciphertextString, conversationKey);
+    return new Uint8Array(Buffer.from(claimString, "base64"));
+  } catch (error) {
+    if (error instanceof GiftWrapError) {
+      throw error;
+    }
+    throw new GiftWrapError(
+      `Failed to decrypt FULFILL claim: ${error instanceof Error ? error.message : String(error)}`,
+      error instanceof Error ? error : void 0
+    );
+  } finally {
+    if (conversationKey) {
+      conversationKey.fill(0);
+      conversationKey = null;
+    }
+  }
+}
+
+// src/swap-handler.ts
+import { createHash } from "crypto";
+var DEFAULT_SEEN_PACKET_IDS_CAP = 1e4;
+var SWAP_HANDLER_REJECT_CODES = {
+  /** Malformed / invalid PREPARE content — gift-wrap shape or amount invalid. */
+  INVALID_GIFT_WRAP: "F01",
+  /** No route — the handler did not match a registered destination. */
+  UNREACHABLE: "F02",
+  /** Duplicate packet — `seenPacketIds` replay hit. */
+  DUPLICATE_PACKET: "F04",
+  /** Requested swap pair is not advertised by this Mill. */
+  UNSUPPORTED_PAIR: "F06",
+  /** Transient internal failure — signing, rate provider, or unexpected. */
+  INTERNAL: "T00",
+  /** Insufficient Mill inventory for the requested amount. */
+  INSUFFICIENT_LIQUIDITY: "T04"
+};
+var SWAP_HANDLER_REJECT_MESSAGES = {
+  INVALID_GIFT_WRAP: "Invalid gift wrap",
+  INVALID_AMOUNT: "Invalid amount",
+  UNREACHABLE: "Unreachable",
+  DUPLICATE_PACKET: "Duplicate packet",
+  UNSUPPORTED_PAIR: "Unsupported swap pair",
+  INTERNAL: "Internal error",
+  INSUFFICIENT_LIQUIDITY: "Insufficient liquidity",
+  RATE_PROVIDER: "Rate provider error",
+  RATE_CONVERSION: "Rate conversion error"
+};
+var BoundedSeenPacketIds = class {
+  #map = /* @__PURE__ */ new Map();
+  #cap;
+  [Symbol.toStringTag] = "Set";
+  constructor(cap = DEFAULT_SEEN_PACKET_IDS_CAP) {
+    if (!Number.isInteger(cap) || cap <= 0) {
+      throw new Error(
+        `BoundedSeenPacketIds cap must be a positive integer, got ${cap}`
+      );
+    }
+    this.#cap = cap;
+  }
+  get size() {
+    return this.#map.size;
+  }
+  /** Exposed for AC-10 test introspection. */
+  get cap() {
+    return this.#cap;
+  }
+  has(value) {
+    if (!this.#map.has(value)) return false;
+    this.#map.delete(value);
+    this.#map.set(value, true);
+    return true;
+  }
+  add(value) {
+    if (this.#map.has(value)) {
+      this.#map.delete(value);
+      this.#map.set(value, true);
+      return this;
+    }
+    this.#map.set(value, true);
+    while (this.#map.size > this.#cap) {
+      const first = this.#map.keys().next();
+      if (first.done) break;
+      this.#map.delete(first.value);
+    }
+    return this;
+  }
+  delete(value) {
+    return this.#map.delete(value);
+  }
+  clear() {
+    this.#map.clear();
+  }
+  forEach(callback, thisArg) {
+    for (const k of this.#map.keys()) {
+      callback.call(thisArg, k, k, this);
+    }
+  }
+  *[Symbol.iterator]() {
+    yield* this.#map.keys();
+  }
+  *keys() {
+    yield* this.#map.keys();
+  }
+  *values() {
+    yield* this.#map.keys();
+  }
+  *entries() {
+    for (const k of this.#map.keys()) yield [k, k];
+  }
+};
+var RATE_REGEX = /^(0|[1-9]\d*)(\.\d+)?$/;
+function applyRate(params) {
+  const { sourceAmount, fromScale, toScale, rate } = params;
+  if (!RATE_REGEX.test(rate)) {
+    throw new SwapHandlerError(`Invalid rate format: ${rate}`);
+  }
+  if (/^0(\.0+)?$/.test(rate)) {
+    throw new SwapHandlerError("Rate is zero (pair not quoting)");
+  }
+  if (sourceAmount <= 0n) {
+    throw new SwapHandlerError(
+      `sourceAmount must be positive, got ${sourceAmount}`
+    );
+  }
+  const dotIdx = rate.indexOf(".");
+  const integerPart = dotIdx === -1 ? rate : rate.slice(0, dotIdx);
+  const fractionalPart = dotIdx === -1 ? "" : rate.slice(dotIdx + 1);
+  const rateNumerator = BigInt(integerPart + fractionalPart);
+  const rateDenominator = 10n ** BigInt(fractionalPart.length);
+  const scaleUp = 10n ** BigInt(toScale);
+  const scaleDown = 10n ** BigInt(fromScale);
+  return sourceAmount * rateNumerator * scaleUp / (rateDenominator * scaleDown);
+}
+function findSwapPair(rumor, pairs) {
+  const fromTag = findTagValue(rumor, "swap-from");
+  const toTag = findTagValue(rumor, "swap-to");
+  if (!fromTag || !toTag) return null;
+  const fromParts = splitAssetChain(fromTag);
+  const toParts = splitAssetChain(toTag);
+  if (!fromParts || !toParts) return null;
+  for (const pair of pairs) {
+    if (pair.from.assetCode === fromParts.assetCode && pair.from.chain === fromParts.chain && pair.to.assetCode === toParts.assetCode && pair.to.chain === toParts.chain) {
+      return pair;
+    }
+  }
+  return null;
+}
+function findTagValue(rumor, tagName) {
+  if (!Array.isArray(rumor.tags)) return void 0;
+  for (const t of rumor.tags) {
+    if (Array.isArray(t) && t[0] === tagName && typeof t[1] === "string") {
+      return t[1];
+    }
+  }
+  return void 0;
+}
+function splitAssetChain(raw) {
+  const idx = raw.indexOf(":");
+  if (idx <= 0 || idx === raw.length - 1) return null;
+  const assetCode = raw.slice(0, idx);
+  const chain = raw.slice(idx + 1);
+  if (!assetCode || !chain) return null;
+  return { assetCode, chain };
+}
+var SWAP_HANDLER_EVM_ADDRESS_REGEX = /^0x[0-9a-f]{40}$/;
+var SWAP_HANDLER_BASE58_REGEX = /^[1-9A-HJ-NP-Za-km-z]+$/;
+function validateChainRecipient(value, chain) {
+  if (typeof value !== "string" || value.length === 0) return false;
+  if (chain.startsWith("evm:")) {
+    return SWAP_HANDLER_EVM_ADDRESS_REGEX.test(value);
+  }
+  if (chain.startsWith("solana:")) {
+    if (!SWAP_HANDLER_BASE58_REGEX.test(value)) return false;
+    if (value.length < 32 || value.length > 44) return false;
+    try {
+      return base58Decode(value).length === 32;
+    } catch {
+      return false;
+    }
+  }
+  if (chain.startsWith("mina:")) {
+    return SWAP_HANDLER_BASE58_REGEX.test(value) && value.length >= 32;
+  }
+  return value.length > 0;
+}
+function findChainRecipient(rumor, chain) {
+  const raw = findTagValue(rumor, "chain-recipient");
+  if (!raw) return null;
+  if (!validateChainRecipient(raw, chain)) return null;
+  return raw;
+}
+var noop = () => void 0;
+var NOOP_LOGGER = {
+  debug: noop,
+  info: noop,
+  warn: noop,
+  error: noop
+};
+function createSwapHandler(config) {
+  if (!(config.recipientSecretKey instanceof Uint8Array) || config.recipientSecretKey.length !== 32) {
+    throw new SwapHandlerError(
+      "recipientSecretKey must be a 32-byte Uint8Array"
+    );
+  }
+  if (!Array.isArray(config.swapPairs)) {
+    throw new SwapHandlerError("swapPairs must be an array");
+  }
+  if (!config.claimIssuer || typeof config.claimIssuer.issueClaim !== "function") {
+    throw new SwapHandlerError(
+      "claimIssuer must implement issueClaim(params): Promise<IssueClaimResult>"
+    );
+  }
+  const logger = config.logger ?? NOOP_LOGGER;
+  const seenPacketIds = config.seenPacketIds ?? new BoundedSeenPacketIds();
+  return async (ctx) => {
+    if (ctx.kind !== 1059) {
+      return ctx.reject("F02", "Unreachable");
+    }
+    if (typeof ctx.amount !== "bigint" || ctx.amount <= 0n) {
+      logger.warn({
+        event: "swap_handler.invalid_amount",
+        destination: ctx.destination
+      });
+      return ctx.reject("F01", "Invalid amount");
+    }
+    if (typeof ctx.toon !== "string" || ctx.toon.length === 0) {
+      logger.warn({
+        event: "swap_handler.invalid_toon",
+        destination: ctx.destination
+      });
+      return ctx.reject("F01", "Invalid gift wrap");
+    }
+    let rumor;
+    let senderPubkey;
+    try {
+      const toonData = new Uint8Array(Buffer.from(ctx.toon, "base64"));
+      ({ rumor, senderPubkey } = unwrapSwapPacketFromToon({
+        toonData,
+        recipientSecretKey: config.recipientSecretKey
+      }));
+    } catch (err) {
+      if (err instanceof GiftWrapError) {
+        logger.warn({
+          event: "swap_handler.unwrap_failed",
+          destination: ctx.destination,
+          error: err.message
+        });
+        return ctx.reject("F01", "Invalid gift wrap");
+      }
+      logger.error({
+        event: "swap_handler.unwrap_unexpected_error",
+        destination: ctx.destination,
+        error: err instanceof Error ? err.message : String(err)
+      });
+      return ctx.reject("F01", "Invalid gift wrap");
+    }
+    const pair = findSwapPair(rumor, config.swapPairs);
+    if (!pair) {
+      logger.debug({
+        event: "swap_handler.unsupported_pair",
+        destination: ctx.destination
+      });
+      return ctx.reject("F06", "Unsupported swap pair");
+    }
+    const chainRecipient = findChainRecipient(rumor, pair.to.chain);
+    if (!chainRecipient) {
+      logger.debug({
+        event: "swap_handler.malformed_rumor",
+        destination: ctx.destination,
+        reason: "missing_or_malformed_chain_recipient",
+        chain: pair.to.chain
+      });
+      return ctx.reject("T00", "Internal error");
+    }
+    const packetId = computePacketId(senderPubkey, ctx.amount, rumor);
+    if (seenPacketIds.has(packetId)) {
+      logger.debug({
+        event: "swap_handler.duplicate_packet",
+        packetId
+      });
+      return ctx.reject("F04", "Duplicate packet");
+    }
+    seenPacketIds.add(packetId);
+    const releaseReservation = () => {
+      seenPacketIds.delete(packetId);
+    };
+    let rate;
+    try {
+      rate = config.rateProvider ? await config.rateProvider(pair) : pair.rate;
+    } catch (err) {
+      logger.error({
+        event: "swap_handler.rate_provider_failed",
+        error: err instanceof Error ? err.message : String(err)
+      });
+      releaseReservation();
+      return ctx.reject("T00", "Rate provider error");
+    }
+    let targetAmount;
+    try {
+      targetAmount = applyRate({
+        sourceAmount: ctx.amount,
+        fromScale: pair.from.assetScale,
+        toScale: pair.to.assetScale,
+        rate
+      });
+      logger.debug({
+        event: "swap_handler.rate_applied",
+        sourceAmount: ctx.amount.toString(),
+        targetAmount: targetAmount.toString(),
+        rate
+      });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      logger.warn({
+        event: "swap_handler.rate_conversion_failed",
+        error: msg
+      });
+      releaseReservation();
+      return ctx.reject("T00", "Rate conversion error");
+    }
+    let claim;
+    let claimId;
+    let settlementChannelId;
+    let settlementNonce;
+    let settlementCumulative;
+    let settlementRecipient;
+    let settlementMillSigner;
+    try {
+      const result = await config.claimIssuer.issueClaim({
+        sourceAmount: ctx.amount,
+        targetAmount,
+        pair,
+        senderPubkey,
+        chainRecipient,
+        rumor
+      });
+      claim = result.claim;
+      claimId = result.claimId;
+      settlementChannelId = result.channelId;
+      settlementNonce = result.nonce;
+      settlementCumulative = result.cumulativeAmount;
+      settlementRecipient = result.recipient;
+      settlementMillSigner = result.millSignerAddress;
+    } catch (err) {
+      const code = err?.code;
+      const message = err instanceof Error ? err.message : String(err);
+      if (code === "INSUFFICIENT_INVENTORY" || /insufficient/i.test(message)) {
+        logger.warn({
+          event: "swap_handler.insufficient_inventory",
+          error: message
+        });
+        releaseReservation();
+        return ctx.reject("T04", "Insufficient liquidity");
+      }
+      logger.error({
+        event: "swap_handler.issuer_failed",
+        error: message
+      });
+      releaseReservation();
+      return ctx.reject("T00", "Internal error");
+    }
+    let ciphertext;
+    let ephemeralPubkey;
+    try {
+      const enc = encryptFulfillClaim({ claimData: claim, senderPubkey });
+      ciphertext = enc.ciphertext;
+      ephemeralPubkey = enc.ephemeralPubkey;
+    } catch (err) {
+      logger.error({
+        event: "swap_handler.encrypt_failed",
+        error: err instanceof Error ? err.message : String(err)
+      });
+      releaseReservation();
+      return ctx.reject("T00", "Internal error");
+    }
+    const claimBase64 = Buffer.from(ciphertext).toString("base64");
+    logger.info({
+      event: "swap_handler.claim_issued",
+      claimId,
+      ephemeralPubkey
+    });
+    const metadata = {
+      claim: claimBase64,
+      ephemeralPubkey,
+      targetAmount: targetAmount.toString()
+    };
+    if (claimId !== void 0) metadata["claimId"] = claimId;
+    if (settlementChannelId !== void 0 && settlementNonce !== void 0 && settlementCumulative !== void 0 && settlementRecipient !== void 0 && settlementMillSigner !== void 0) {
+      metadata["channelId"] = settlementChannelId;
+      metadata["nonce"] = settlementNonce.toString();
+      metadata["cumulativeAmount"] = settlementCumulative.toString();
+      metadata["recipient"] = settlementRecipient;
+      metadata["millSignerAddress"] = settlementMillSigner;
+    }
+    return ctx.accept(metadata);
+  };
+}
+function computePacketId(senderPubkey, sourceAmount, rumor) {
+  const rumorId = rumor.id ?? "";
+  const hash = createHash("sha256");
+  const parts = [senderPubkey, sourceAmount.toString(), rumorId];
+  for (const p of parts) {
+    const buf = Buffer.from(p, "utf8");
+    const lenBuf = Buffer.alloc(4);
+    lenBuf.writeUInt32BE(buf.length, 0);
+    hash.update(lenBuf);
+    hash.update(buf);
+  }
+  return hash.digest("hex");
+}
+
+// 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 BASE64_REGEX = /^[A-Za-z0-9+/]+={0,2}$/;
+function isBase64(s) {
+  if (s.length === 0 || s.length % 4 !== 0) return false;
+  return BASE64_REGEX.test(s);
+}
+function chunkAmount(total, count) {
+  if (!Number.isInteger(count) || count <= 0 || count > Number.MAX_SAFE_INTEGER) {
+    throw new StreamSwapError(
+      "INVALID_CHUNKING",
+      `packetCount must be a positive integer, got ${count}`
+    );
+  }
+  if (total < BigInt(count)) {
+    throw new StreamSwapError(
+      "INVALID_CHUNKING",
+      `totalAmount (${total}) must be >= packetCount (${count}) so per-packet amount >= 1`
+    );
+  }
+  const base = total / BigInt(count);
+  const remainder = total - base * BigInt(count);
+  const out = new Array(count);
+  for (let i = 0; i < count; i++) out[i] = base;
+  const last = out[count - 1] ?? 0n;
+  out[count - 1] = last + remainder;
+  return out;
+}
+function buildSwapRumor(input) {
+  const {
+    senderPubkey,
+    pair,
+    sourceAmount,
+    packetIndex,
+    totalPackets,
+    nonce,
+    createdAt,
+    chainRecipient
+  } = input;
+  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]
+    ]
+  };
+}
+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 BASE58_REGEX = /^[1-9A-HJ-NP-Za-km-z]+$/;
+function validateChainAddress(value, chain, kind) {
+  if (chain.startsWith("evm:")) {
+    const normalized = value.toLowerCase();
+    if (kind === "channelId") return EVM_CHANNEL_ID_REGEX.test(normalized);
+    return EVM_ADDRESS_REGEX.test(normalized);
+  }
+  if (chain.startsWith("solana:")) {
+    if (!BASE58_REGEX.test(value)) return false;
+    if (value.length < 32 || value.length > 44) return false;
+    try {
+      return base58Decode(value).length === 32;
+    } catch {
+      return false;
+    }
+  }
+  if (chain.startsWith("mina:")) {
+    return BASE58_REGEX.test(value) && value.length >= 32;
+  }
+  return value.length > 0;
+}
+function decodeFulfillMetadata(data, chain) {
+  if (data === void 0 || data === null || data === "") {
+    throw new StreamSwapError("FULFILL_DECODE_FAILED", "FULFILL data missing");
+  }
+  if (!isBase64(data)) {
+    throw new StreamSwapError(
+      "FULFILL_DECODE_FAILED",
+      "FULFILL data is not valid base64"
+    );
+  }
+  let jsonBytes;
+  try {
+    jsonBytes = Buffer.from(data, "base64");
+  } catch (err) {
+    throw new StreamSwapError(
+      "FULFILL_DECODE_FAILED",
+      `FULFILL data base64 decode failed: ${err instanceof Error ? err.message : String(err)}`,
+      { cause: err }
+    );
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(jsonBytes.toString("utf8"));
+  } catch (err) {
+    throw new StreamSwapError(
+      "FULFILL_DECODE_FAILED",
+      `FULFILL data JSON parse failed: ${err instanceof Error ? err.message : String(err)}`,
+      { cause: err }
+    );
+  }
+  if (!parsed || typeof parsed !== "object") {
+    throw new StreamSwapError(
+      "FULFILL_DECODE_FAILED",
+      "FULFILL metadata is not an object"
+    );
+  }
+  const obj = parsed;
+  const claim = obj["claim"];
+  const ephemeralPubkey = obj["ephemeralPubkey"];
+  if (typeof claim !== "string" || !isBase64(claim)) {
+    throw new StreamSwapError(
+      "FULFILL_DECODE_FAILED",
+      "FULFILL metadata.claim is missing or not base64 string"
+    );
+  }
+  if (typeof ephemeralPubkey !== "string" || !HEX64_REGEX.test(ephemeralPubkey)) {
+    throw new StreamSwapError(
+      "FULFILL_DECODE_FAILED",
+      "FULFILL metadata.ephemeralPubkey is missing or not 64-char hex"
+    );
+  }
+  const result = {
+    claim,
+    ephemeralPubkey
+  };
+  if (typeof obj["claimId"] === "string") {
+    result.claimId = obj["claimId"];
+  }
+  if (obj["targetAmount"] !== void 0) {
+    const ta = obj["targetAmount"];
+    if (typeof ta !== "string" || !/^(0|[1-9]\d*)$/.test(ta)) {
+      throw new StreamSwapError(
+        "FULFILL_DECODE_FAILED",
+        "FULFILL metadata.targetAmount must be a non-negative integer decimal string"
+      );
+    }
+    result.targetAmount = ta;
+  }
+  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)) {
+    result.nonce = nonce;
+  }
+  const cumulativeAmount = obj["cumulativeAmount"];
+  if (typeof cumulativeAmount === "string" && DECIMAL_UINT_REGEX.test(cumulativeAmount)) {
+    result.cumulativeAmount = cumulativeAmount;
+  }
+  const recipient = obj["recipient"];
+  if (typeof recipient === "string" && recipient.length > 0) {
+    result.recipient = recipient;
+  }
+  const millSignerAddress = obj["millSignerAddress"];
+  if (typeof millSignerAddress === "string" && (!chain || validateChainAddress(millSignerAddress, chain, "address"))) {
+    result.millSignerAddress = millSignerAddress;
+  }
+  return result;
+}
+var Deferred = class {
+  promise;
+  resolve;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any -- mirror Promise constructor
+  reject;
+  constructor() {
+    this.promise = new Promise((res, rej) => {
+      this.resolve = res;
+      this.reject = rej;
+    });
+  }
+};
+var noop2 = () => void 0;
+var NOOP_LOGGER2 = {
+  debug: noop2,
+  info: noop2,
+  warn: noop2,
+  error: noop2
+};
+function validateParams(params) {
+  if (typeof params.totalAmount !== "bigint" || params.totalAmount <= 0n) {
+    throw new StreamSwapError(
+      "INVALID_AMOUNT",
+      `totalAmount must be a positive bigint, got ${String(params.totalAmount)}`
+    );
+  }
+  const hasCount = params.packetCount !== void 0;
+  const hasAmounts = params.packetAmounts !== void 0;
+  if (hasCount === hasAmounts) {
+    throw new StreamSwapError(
+      "INVALID_CHUNKING",
+      "Exactly one of packetCount or packetAmounts must be provided"
+    );
+  }
+  if (hasCount) {
+    const c = params.packetCount;
+    if (!Number.isInteger(c) || c <= 0) {
+      throw new StreamSwapError(
+        "INVALID_CHUNKING",
+        `packetCount must be a positive integer, got ${c}`
+      );
+    }
+    if (BigInt(c) > params.totalAmount) {
+      throw new StreamSwapError(
+        "INVALID_CHUNKING",
+        `packetCount (${c}) exceeds totalAmount (${params.totalAmount}); per-packet amount would be < 1 micro-unit`
+      );
+    }
+  } else {
+    const arr = params.packetAmounts;
+    if (!Array.isArray(arr) || arr.length === 0) {
+      throw new StreamSwapError(
+        "INVALID_CHUNKING",
+        "packetAmounts must be a non-empty array"
+      );
+    }
+    let sum = 0n;
+    for (const a of arr) {
+      if (typeof a !== "bigint" || a <= 0n) {
+        throw new StreamSwapError(
+          "INVALID_CHUNKING",
+          `packetAmounts entries must be positive bigint, got ${String(a)}`
+        );
+      }
+      sum += a;
+    }
+    if (sum !== params.totalAmount) {
+      throw new StreamSwapError(
+        "INVALID_CHUNKING",
+        `sum(packetAmounts) (${sum}) !== totalAmount (${params.totalAmount})`
+      );
+    }
+  }
+  if (!(params.senderSecretKey instanceof Uint8Array) || params.senderSecretKey.length !== 32) {
+    throw new StreamSwapError(
+      "INVALID_STATE",
+      "senderSecretKey must be a 32-byte Uint8Array"
+    );
+  }
+  if (typeof params.millPubkey !== "string" || !HEX64_REGEX.test(params.millPubkey)) {
+    throw new StreamSwapError(
+      "INVALID_STATE",
+      "millPubkey must be a 64-char lowercase hex string"
+    );
+  }
+  if (!params.pair || typeof params.pair !== "object") {
+    throw new StreamSwapError("INVALID_PAIR", "pair is required");
+  }
+  if (!params.pair.from || typeof params.pair.from !== "object" || typeof params.pair.from.assetCode !== "string" || typeof params.pair.from.assetScale !== "number" || typeof params.pair.from.chain !== "string") {
+    throw new StreamSwapError(
+      "INVALID_PAIR",
+      "pair.from must have { assetCode: string, assetScale: number, chain: string }"
+    );
+  }
+  if (!params.pair.to || typeof params.pair.to !== "object" || typeof params.pair.to.assetCode !== "string" || typeof params.pair.to.assetScale !== "number" || typeof params.pair.to.chain !== "string") {
+    throw new StreamSwapError(
+      "INVALID_PAIR",
+      "pair.to must have { assetCode: string, assetScale: number, chain: string }"
+    );
+  }
+  if (typeof params.pair.rate !== "string" || !RATE_REGEX2.test(params.pair.rate)) {
+    throw new StreamSwapError(
+      "INVALID_PAIR",
+      `pair.rate must match ${RATE_REGEX2}, got ${params.pair.rate}`
+    );
+  }
+  try {
+    applyRate({
+      sourceAmount: 1n,
+      fromScale: params.pair.from.assetScale,
+      toScale: params.pair.to.assetScale,
+      rate: params.pair.rate
+    });
+  } catch (err) {
+    throw new StreamSwapError(
+      "INVALID_PAIR",
+      `pair failed applyRate sanity check: ${err instanceof Error ? err.message : String(err)}`,
+      { cause: err }
+    );
+  }
+  if (params.rateDeviationThreshold !== void 0 && (typeof params.rateDeviationThreshold !== "number" || !Number.isFinite(params.rateDeviationThreshold) || params.rateDeviationThreshold < 0)) {
+    throw new StreamSwapError(
+      "INVALID_STATE",
+      `rateDeviationThreshold must be a non-negative finite number, got ${params.rateDeviationThreshold}`
+    );
+  }
+  if (typeof params.chainRecipient !== "string" || params.chainRecipient.length === 0) {
+    throw new StreamSwapError(
+      "INVALID_STATE",
+      "chainRecipient must be a non-empty string (sender payout address for pair.to.chain)"
+    );
+  }
+  if (!validateChainAddress(
+    params.chainRecipient,
+    params.pair.to.chain,
+    "address"
+  )) {
+    throw new StreamSwapError(
+      "INVALID_CHAIN_RECIPIENT",
+      `chainRecipient ${params.chainRecipient} is malformed for chain ${params.pair.to.chain}`
+    );
+  }
+}
+async function streamSwap(params) {
+  return streamSwapControlled(params).result;
+}
+function streamSwapControlled(params) {
+  validateParams(params);
+  const logger = params.logger ?? NOOP_LOGGER2;
+  const schedule = params.packetAmounts ? [...params.packetAmounts] : 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);
+  let streamState = "running";
+  let resumeDeferred = null;
+  const controller = {
+    pause() {
+      if (streamState === "running") {
+        streamState = "paused";
+      }
+    },
+    resume() {
+      if (streamState === "paused") {
+        streamState = "running";
+        if (resumeDeferred) {
+          resumeDeferred.resolve("resume");
+          resumeDeferred = null;
+        }
+      } else if (streamState === "running") {
+      } else {
+        throw new StreamSwapError(
+          "INVALID_STATE",
+          `Cannot resume from state "${streamState}"`
+        );
+      }
+    },
+    stop() {
+      if (streamState === "completed" || streamState === "failed") return;
+      const prev = streamState;
+      streamState = "stopped";
+      if (prev === "paused" && resumeDeferred) {
+        resumeDeferred.resolve("stop");
+        resumeDeferred = null;
+      }
+    },
+    get state() {
+      return streamState;
+    }
+  };
+  const result = 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;
+    }
+  );
+  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;
+  let packetsSent = 0;
+  let abortReason = "complete";
+  const totalPackets = schedule.length;
+  const isAborted = () => params.signal?.aborted === true;
+  packetLoop: for (let packetIndex = 0; packetIndex < totalPackets; packetIndex++) {
+    if (isAborted()) {
+      abortReason = "aborted";
+      break;
+    }
+    if (getState() === "stopped") {
+      abortReason = "stopped";
+      break;
+    }
+    if (getState() === "paused") {
+      const resumedBy = await waitForResumeOrStop();
+      if (resumedBy === "stop" || getState() === "stopped") {
+        abortReason = "stopped";
+        break;
+      }
+      if (isAborted()) {
+        abortReason = "aborted";
+        break;
+      }
+    }
+    const sourceAmount = schedule[packetIndex];
+    if (sourceAmount === void 0) {
+      throw new StreamSwapError(
+        "INVALID_STATE",
+        `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;
+    try {
+      const wrapped = wrapSwapPacketToToon({
+        rumor,
+        senderSecretKey: params.senderSecretKey,
+        recipientPubkey: params.millPubkey,
+        destination: params.millIlpAddress,
+        amount: sourceAmount
+      });
+      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({
+        packetIndex,
+        cause: err instanceof Error ? err : new Error(String(err))
+      });
+      continue;
+    }
+    let sendResult;
+    try {
+      sendResult = await params.client.sendSwapPacket({
+        destination: params.millIlpAddress,
+        amount: sourceAmount,
+        toonData,
+        timeout: params.packetTimeoutMs ?? 3e4,
+        claim: params.claim
+      });
+      packetsSent += 1;
+    } catch (err) {
+      logger.error({
+        event: "stream_swap.send_failed",
+        packetIndex,
+        error: err instanceof Error ? err.message : String(err)
+      });
+      errors.push({
+        packetIndex,
+        cause: err instanceof Error ? err : new Error(String(err))
+      });
+      continue;
+    }
+    if (!sendResult.accepted) {
+      const code = sendResult.code ?? "F00";
+      const message = sendResult.message ?? "rejected";
+      logger.warn({
+        event: "stream_swap.packet_rejected",
+        packetIndex,
+        code,
+        message
+      });
+      rejections.push({ packetIndex, sourceAmount, code, message });
+      continue;
+    }
+    let metadata;
+    try {
+      metadata = decodeFulfillMetadata(sendResult.data, pair.to.chain);
+    } catch (err) {
+      logger.error({
+        event: "stream_swap.fulfill_decode_failed",
+        packetIndex,
+        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: "MILL_RECIPIENT_MISMATCH",
+        message: `Mill echoed recipient ${metadata.recipient} but sender expected ${params.chainRecipient}`
+      });
+      continue;
+    }
+    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)
+      });
+      errors.push({
+        packetIndex,
+        cause: err instanceof Error ? err : new Error(String(err))
+      });
+      continue;
+    }
+    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;
+    }
+    cumulativeSource += sourceAmount;
+    cumulativeTarget += targetAmount;
+    const accumulated = {
+      packetIndex,
+      sourceAmount,
+      targetAmount,
+      claimBytes,
+      millEphemeralPubkey: 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.millSignerAddress !== void 0)
+      accumulated.millSignerAddress = metadata.millSignerAddress;
+    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: 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)
+        });
+        errors.push({
+          packetIndex,
+          cause: err instanceof Error ? err : new Error(String(err))
+        });
+        abortReason = "callback-throw";
+        break packetLoop;
+      }
+    }
+    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,
+    abortReason,
+    cumulativeSource,
+    cumulativeTarget,
+    packetsSent,
+    packetsScheduled: totalPackets
+  };
+}
+function getRandomValues(buf) {
+  const g = globalThis;
+  if (g.crypto && typeof g.crypto.getRandomValues === "function") {
+    g.crypto.getRandomValues(buf);
+    return buf;
+  }
+  const nodeCrypto = __require("crypto");
+  if (nodeCrypto.webcrypto?.getRandomValues) {
+    nodeCrypto.webcrypto.getRandomValues(buf);
+    return buf;
+  }
+  if (nodeCrypto.randomFillSync) {
+    nodeCrypto.randomFillSync(buf);
+    return buf;
+  }
+  throw new StreamSwapError(
+    "INVALID_STATE",
+    "No crypto.getRandomValues available in this environment"
+  );
+}
+var __testing = {
+  chunkAmount,
+  decodeFulfillMetadata,
+  buildSwapRumor
+};
+
+export {
+  IdentityError,
+  NodeError,
+  HandlerError,
+  VerificationError,
+  PricingError,
+  GiftWrapError,
+  SwapHandlerError,
+  StreamSwapError,
+  SettlementTxError,
+  generateMnemonic,
+  fromMnemonic,
+  fromSecretKey,
+  fromMnemonicFull,
+  generateSolanaKeypair,
+  base58Encode,
+  base58Decode,
+  wrapSwapPacket,
+  unwrapSwapPacket,
+  wrapSwapPacketToToon,
+  unwrapSwapPacketFromToon,
+  encryptFulfillClaim,
+  decryptFulfillClaim,
+  SWAP_HANDLER_REJECT_CODES,
+  SWAP_HANDLER_REJECT_MESSAGES,
+  applyRate,
+  findSwapPair,
+  createSwapHandler,
+  streamSwap,
+  streamSwapControlled,
+  __testing
+};
+//# sourceMappingURL=chunk-XTHUXP63.js.map