@toon-protocol/sdk 0.4.0 → 0.5.1

package/dist/index.js

@@ -1,145 +1,36 @@
-import "./chunk-UP2VWCW5.js";
-
-// src/identity.ts
 import {
-  generateMnemonic as _generateMnemonic,
-  validateMnemonic,
-  mnemonicToSeedSync
-} from "@scure/bip39";
-import { wordlist } from "@scure/bip39/wordlists/english.js";
-import { HDKey } from "@scure/bip32";
-import { getPublicKey } from "nostr-tools/pure";
-import { secp256k1 } from "@noble/curves/secp256k1.js";
-import { keccak_256 } from "@noble/hashes/sha3.js";
-import { bytesToHex } from "@noble/hashes/utils.js";
-
-// src/errors.ts
-import { ToonError } from "@toon-protocol/core";
-var IdentityError = class extends ToonError {
-  constructor(message, cause) {
-    super(message, "IDENTITY_ERROR", cause);
-    this.name = "IdentityError";
-  }
-};
-var NodeError = class extends ToonError {
-  constructor(message, cause) {
-    super(message, "NODE_ERROR", cause);
-    this.name = "NodeError";
-  }
-};
-var HandlerError = class extends ToonError {
-  constructor(message, cause) {
-    super(message, "HANDLER_ERROR", cause);
-    this.name = "HandlerError";
-  }
-};
-var VerificationError = class extends ToonError {
-  constructor(message, cause) {
-    super(message, "VERIFICATION_ERROR", cause);
-    this.name = "VerificationError";
-  }
-};
-var PricingError = class extends ToonError {
-  constructor(message, cause) {
-    super(message, "PRICING_ERROR", cause);
-    this.name = "PricingError";
-  }
-};
-
-// src/identity.ts
-function generateMnemonic() {
-  return _generateMnemonic(wordlist, 128);
-}
-function fromMnemonic(mnemonic, options) {
-  if (!validateMnemonic(mnemonic, wordlist)) {
-    throw new IdentityError(
-      `Invalid BIP-39 mnemonic: the provided words do not form a valid mnemonic phrase`
-    );
-  }
-  const accountIndex = options?.accountIndex ?? 0;
-  if (!Number.isInteger(accountIndex) || accountIndex < 0 || accountIndex > MAX_BIP32_INDEX) {
-    throw new IdentityError(
-      `Invalid accountIndex: expected a non-negative integer (0 to ${MAX_BIP32_INDEX}), got ${String(accountIndex)}`
-    );
-  }
-  const path = `m/44'/1237'/0'/0/${accountIndex}`;
-  let seed;
-  try {
-    seed = mnemonicToSeedSync(mnemonic);
-    const hdKey = HDKey.fromMasterSeed(seed).derive(path);
-    if (!hdKey.privateKey) {
-      throw new IdentityError(`Failed to derive private key at path ${path}`);
-    }
-    const secretKey = hdKey.privateKey;
-    return deriveIdentity(secretKey);
-  } catch (error) {
-    if (error instanceof IdentityError) {
-      throw error;
-    }
-    throw new IdentityError(
-      `Key derivation failed at path ${path}: ${error instanceof Error ? error.message : String(error)}`,
-      error instanceof Error ? error : void 0
-    );
-  } finally {
-    if (seed) {
-      seed.fill(0);
-    }
-  }
-}
-function fromSecretKey(secretKey) {
-  if (!(secretKey instanceof Uint8Array)) {
-    throw new IdentityError(
-      `Invalid secret key: expected Uint8Array, got ${secretKey === null ? "null" : typeof secretKey}`
-    );
-  }
-  if (secretKey.length !== 32) {
-    throw new IdentityError(
-      `Invalid secret key: expected 32 bytes, got ${secretKey.length} bytes`
-    );
-  }
-  try {
-    return deriveIdentity(secretKey);
-  } catch (error) {
-    if (error instanceof IdentityError) {
-      throw error;
-    }
-    throw new IdentityError(
-      `Invalid secret key: ${error instanceof Error ? error.message : String(error)}`,
-      error instanceof Error ? error : void 0
-    );
-  }
-}
-var MAX_BIP32_INDEX = 2147483647;
-function deriveIdentity(secretKey) {
-  const pubkey = getPublicKey(secretKey);
-  const evmAddress = computeEvmAddress(secretKey);
-  return { secretKey: new Uint8Array(secretKey), pubkey, evmAddress };
-}
-function computeEvmAddress(secretKey) {
-  const uncompressedPubkey = secp256k1.getPublicKey(secretKey, false);
-  const pubkeyWithoutPrefix = uncompressedPubkey.slice(1);
-  const hash = keccak_256(pubkeyWithoutPrefix);
-  const addressBytes = hash.slice(-20);
-  const addressHex = bytesToHex(addressBytes);
-  return toChecksumAddress(addressHex);
-}
-function toChecksumAddress(addressHex) {
-  const lower = addressHex.toLowerCase();
-  const hash = bytesToHex(keccak_256(new TextEncoder().encode(lower)));
-  let checksummed = "0x";
-  for (let i = 0; i < 40; i++) {
-    const char = lower[i];
-    const hashChar = hash[i];
-    if (char === void 0 || hashChar === void 0) {
-      throw new IdentityError(
-        `Unexpected undefined at index ${i} during checksum computation`
-      );
-    }
-    const hashNibble = parseInt(hashChar, 16);
-    checksummed += hashNibble >= 8 ? char.toUpperCase() : char;
-  }
-  return checksummed;
-}
+  GiftWrapError,
+  HandlerError,
+  IdentityError,
+  NodeError,
+  PricingError,
+  SWAP_HANDLER_REJECT_CODES,
+  SWAP_HANDLER_REJECT_MESSAGES,
+  SettlementTxError,
+  StreamSwapError,
+  SwapHandlerError,
+  VerificationError,
+  __testing,
+  applyRate,
+  base58Decode,
+  base58Encode,
+  createSwapHandler,
+  decryptFulfillClaim,
+  encryptFulfillClaim,
+  findSwapPair,
+  fromMnemonic,
+  fromMnemonicFull,
+  fromSecretKey,
+  generateMnemonic,
+  generateSolanaKeypair,
+  streamSwap,
+  streamSwapControlled,
+  unwrapSwapPacket,
+  unwrapSwapPacketFromToon,
+  wrapSwapPacket,
+  wrapSwapPacketToToon
+} from "./chunk-XTHUXP63.js";
+import "./chunk-UP2VWCW5.js";
 
 // src/handler-context.ts
 function createHandlerContext(options) {
@@ -208,6 +99,13 @@ var HandlerRegistry = class {
   getRegisteredKinds() {
     return [...this.handlers.keys()].sort((a, b) => a - b);
   }
+  /**
+   * Returns the handler registered for `kind`, or `undefined` if none.
+   * Added for Story 12.7 AC-10 (handler-registration verification).
+   */
+  get(kind) {
+    return this.handlers.get(kind);
+  }
   /**
    * Returns registered kinds in the DVM request range (5000-5999), sorted ascending.
    * Uses JOB_REQUEST_KIND_BASE (5000) as the range start.
@@ -387,7 +285,8 @@ import {
   calculateRouteAmount,
   resolveRouteFees,
   buildPrefixClaimEvent,
-  validatePrefix
+  validatePrefix,
+  ilpCodeToSemantic
 } from "@toon-protocol/core";
 import {
   shallowParseToon,
@@ -396,7 +295,7 @@ import {
 } from "@toon-protocol/core/toon";
 
 // src/skill-descriptor.ts
-import { ToonError as ToonError2 } from "@toon-protocol/core";
+import { ToonError } from "@toon-protocol/core";
 var HEX_64_REGEX = /^[0-9a-f]{64}$/;
 function buildSkillDescriptor(registry, config = {}) {
   const dvmKinds = registry.getDvmKinds();
@@ -405,7 +304,7 @@ function buildSkillDescriptor(registry, config = {}) {
   }
   if (config.attestation !== void 0) {
     if (!HEX_64_REGEX.test(config.attestation.eventId)) {
-      throw new ToonError2(
+      throw new ToonError(
         "Skill descriptor attestation eventId must be a 64-character lowercase hex string",
         "DVM_SKILL_INVALID_ATTESTATION_EVENT_ID"
       );
@@ -596,6 +495,27 @@ function createNode(config) {
           trackerRef.current.processEvent(decoded);
         }
       }
+      if (result.accept && result.metadata && !result.data) {
+        try {
+          const metadataJson = JSON.stringify(result.metadata);
+          result.data = Buffer.from(
+            metadataJson,
+            "utf8"
+          ).toString("base64");
+        } catch (err) {
+          console.error(
+            "Failed to serialize handler metadata to FULFILL data:",
+            err instanceof Error ? err.message : err
+          );
+        }
+      }
+      if (!result.accept && !result.rejectReason && result.code) {
+        const ilpCode = result.code;
+        result.rejectReason = {
+          code: ilpCodeToSemantic(ilpCode),
+          message: result.message ?? "Payment rejected"
+        };
+      }
       return result;
     } catch (err) {
       const errMsg = err instanceof Error ? err.message : "Unknown error";
@@ -736,32 +656,36 @@ function createNode(config) {
       }
       const hasSettlementAddresses = chainConfig.registryAddress && chainConfig.tokenNetworkAddress;
       const hasChainProviders = config.chainProviders !== void 0 && config.chainProviders.length > 0;
-      autoCreatedConnector = new ConnectorNodeClass(
+      const effectiveChainProviders = hasChainProviders ? config.chainProviders : hasSettlementAddresses ? [
         {
-          nodeId,
-          btpServerPort,
-          environment: "development",
-          deploymentMode: "embedded",
-          peers: [],
-          routes: [],
-          localDelivery: { enabled: false },
-          // Multi-chain: use chainProviders when provided
-          ...hasChainProviders && {
-            chainProviders: config.chainProviders
-          },
-          // Legacy: fall back to settlementInfra when chainProviders absent
-          ...!hasChainProviders && hasSettlementAddresses && {
-            settlementInfra: {
-              enabled: true,
-              rpcUrl: chainConfig.rpcUrl,
-              registryAddress: chainConfig.registryAddress,
-              tokenAddress: chainConfig.usdcAddress,
-              privateKey: settlementPrivateKey
-            }
-          },
-          // NIP-59 transport privacy
-          ...config.nip59 && { nip59: config.nip59 }
-        },
+          chainType: "evm",
+          chainId: `evm:${chainConfig.chainId ?? "31337"}`,
+          rpcUrl: chainConfig.rpcUrl,
+          registryAddress: chainConfig.registryAddress,
+          tokenAddress: chainConfig.usdcAddress,
+          privateKey: settlementPrivateKey
+        }
+      ] : void 0;
+      const connectorConfig = {
+        nodeId,
+        btpServerPort,
+        environment: "development",
+        deploymentMode: "embedded",
+        peers: [],
+        routes: [],
+        localDelivery: { enabled: false }
+      };
+      if (effectiveChainProviders) {
+        connectorConfig.chainProviders = effectiveChainProviders;
+      }
+      if (config.transport) {
+        connectorConfig.transport = config.transport;
+      }
+      if (config.nip59) {
+        connectorConfig.nip59 = config.nip59;
+      }
+      autoCreatedConnector = new ConnectorNodeClass(
+        connectorConfig,
         connectorLogger
       );
       await autoCreatedConnector.start();
@@ -1506,7 +1430,7 @@ var WorkflowOrchestrator = class {
 
 // src/swarm-coordinator.ts
 import {
-  ToonError as ToonError3,
+  ToonError as ToonError2,
   parseSwarmRequest,
   parseSwarmSelection
 } from "@toon-protocol/core";
@@ -1557,7 +1481,7 @@ var SwarmCoordinator = class {
   async startSwarm(swarmRequest) {
     const parsed = parseSwarmRequest(swarmRequest);
     if (!parsed) {
-      throw new ToonError3(
+      throw new ToonError2(
         "Invalid swarm request event: missing swarm tag or invalid Kind 5xxx",
         "DVM_INVALID_KIND"
       );
@@ -1616,32 +1540,32 @@ var SwarmCoordinator = class {
    */
   async selectWinner(selectionEvent) {
     if (this.state === "settled") {
-      throw new ToonError3(
+      throw new ToonError2(
         "Swarm has already been settled; duplicate selection rejected",
         "DVM_SWARM_ALREADY_SETTLED"
       );
     }
     if (this.state !== "judging") {
-      throw new ToonError3(
+      throw new ToonError2(
         `Cannot select winner in state '${this.state}'; swarm must be in 'judging' state`,
         "DVM_SWARM_INVALID_SELECTION"
       );
     }
     if (selectionEvent.pubkey !== this.customerPubkey) {
-      throw new ToonError3(
+      throw new ToonError2(
         "Selection event pubkey does not match the swarm request customer pubkey",
         "DVM_SWARM_INVALID_SELECTION"
       );
     }
     const parsed = parseSwarmSelection(selectionEvent);
     if (!parsed) {
-      throw new ToonError3(
+      throw new ToonError2(
         "Invalid swarm selection event: missing winner tag or invalid Kind 7000",
         "DVM_SWARM_INVALID_SELECTION"
       );
     }
     if (parsed.swarmRequestEventId !== this.swarmRequestId) {
-      throw new ToonError3(
+      throw new ToonError2(
         `Selection event references swarm '${parsed.swarmRequestEventId}' but this swarm is '${this.swarmRequestId}'`,
         "DVM_SWARM_INVALID_SELECTION"
       );
@@ -1650,7 +1574,7 @@ var SwarmCoordinator = class {
       (s) => s.id === parsed.winnerResultEventId
     );
     if (!winnerSubmission) {
-      throw new ToonError3(
+      throw new ToonError2(
         `Winner result event ID '${parsed.winnerResultEventId}' not found in collected submissions`,
         "DVM_SWARM_INVALID_SELECTION"
       );
@@ -1661,7 +1585,7 @@ var SwarmCoordinator = class {
       this.settlementSucceeded = true;
     } catch (_err) {
       this.settlementSucceeded = false;
-      throw new ToonError3(
+      throw new ToonError2(
         "Settlement failed for winning provider; swarm remains in judging state for retry",
         "DVM_SWARM_SETTLEMENT_FAILED"
       );
@@ -1825,6 +1749,10 @@ function createArweaveDvmHandler(config) {
           data: Buffer.from(txId).toString("base64")
         };
       } catch (error) {
+        console.error(
+          "[ArweaveDvmHandler] Chunked upload failed:",
+          error instanceof Error ? error.stack ?? error.message : error
+        );
         const internalMsg = error instanceof Error ? error.message : "Unknown chunk error";
         const safeMsg = internalMsg.includes("Duplicate chunkIndex") ? "Duplicate chunk rejected" : internalMsg.includes("Max active uploads") ? "Server busy, too many concurrent uploads" : internalMsg.includes("exceeds max bytes") ? "Upload size limit exceeded" : "Chunk processing error";
         return {
@@ -1840,7 +1768,11 @@ function createArweaveDvmHandler(config) {
         accept: true,
         data: Buffer.from(txId).toString("base64")
       };
-    } catch {
+    } catch (error) {
+      const cause = error instanceof Error ? error.stack ?? error.message : String(error);
+      console.error(
+        `[ArweaveDvmHandler] Arweave upload failed (${parsed.blobData.length} bytes). Cause: ${cause}`
+      );
       return {
         accept: false,
         code: "T00",
@@ -2062,18 +1994,1076 @@ async function uploadBlobChunked(node, blob, destination, options) {
   }
   return lastResult.eventId;
 }
+
+// src/settlement/evm.ts
+import { secp256k1 } from "@noble/curves/secp256k1.js";
+import { keccak_256 } from "@noble/hashes/sha3.js";
+import { bytesToHex } from "@noble/hashes/utils.js";
+
+// src/settlement/hashes.ts
+import {
+  hexToBytes as hexToBytes2,
+  bigintToBytes32BE,
+  concatBytes,
+  balanceProofHashEvm,
+  balanceProofHashSolana,
+  minaHashToField,
+  balanceProofFieldsMina
+} from "@toon-protocol/core";
+
+// src/settlement/evm.ts
+var EVM_SETTLEMENT_FUNCTION_SIGNATURE = "updateBalance(bytes32,uint256,uint256,address,bytes)";
+var EVM_SETTLEMENT_EVENT_SIGNATURE = "SettlementSucceeded(bytes32,uint256,uint256,address)";
+var EVM_SETTLEMENT_FUNCTION_SELECTOR = keccak_256(
+  new TextEncoder().encode(EVM_SETTLEMENT_FUNCTION_SIGNATURE)
+).slice(0, 4);
+var EVM_SETTLEMENT_EVENT_TOPIC = "0x" + bytesToHex(
+  keccak_256(new TextEncoder().encode(EVM_SETTLEMENT_EVENT_SIGNATURE))
+);
+function recoverEvmSignerAddress(claim) {
+  if (claim.channelId === void 0 || claim.cumulativeAmount === void 0 || claim.nonce === void 0 || claim.recipient === void 0) {
+    throw new SettlementTxError(
+      "MISSING_SETTLEMENT_METADATA",
+      "Claim missing channelId/cumulativeAmount/nonce/recipient for EVM signer recovery"
+    );
+  }
+  if (claim.claimBytes.length !== 65) {
+    throw new SettlementTxError(
+      "INVALID_SIGNATURE_LENGTH",
+      `EVM signature must be 65 bytes (r||s||v), got ${claim.claimBytes.length}`
+    );
+  }
+  const v = claim.claimBytes[64];
+  if (v !== 27 && v !== 28) {
+    throw new SettlementTxError(
+      "INVALID_SIGNATURE_V",
+      `EVM signature v must be 27 or 28, got ${v}`
+    );
+  }
+  const recovery = v - 27;
+  const compactRS = claim.claimBytes.slice(0, 64);
+  let msgHash;
+  let uncompressedPubkey;
+  try {
+    const channelIdBytes = hexToBytes2(claim.channelId);
+    const recipientBytes = hexToBytes2(claim.recipient);
+    if (channelIdBytes.length !== 32) {
+      throw new Error(
+        `channelId must be 32 bytes (got ${channelIdBytes.length})`
+      );
+    }
+    if (recipientBytes.length !== 20) {
+      throw new Error(
+        `recipient must be 20 bytes (got ${recipientBytes.length})`
+      );
+    }
+    msgHash = balanceProofHashEvm(
+      channelIdBytes,
+      BigInt(claim.cumulativeAmount),
+      BigInt(claim.nonce),
+      recipientBytes
+    );
+    const sig = secp256k1.Signature.fromBytes(
+      compactRS,
+      "compact"
+    ).addRecoveryBit(recovery);
+    const point = sig.recoverPublicKey(msgHash);
+    uncompressedPubkey = point.toBytes(false);
+  } catch (err) {
+    throw new SettlementTxError(
+      "ENCODING_FAILED",
+      `EVM signer recovery failed: ${err instanceof Error ? err.message : String(err)}`,
+      { cause: err }
+    );
+  }
+  const addrHash = keccak_256(uncompressedPubkey.slice(1));
+  return "0x" + bytesToHex(addrHash.slice(-20)).toLowerCase();
+}
+function padLeft32(bytes) {
+  if (bytes.length > 32) {
+    throw new SettlementTxError(
+      "ENCODING_FAILED",
+      `cannot pad bytes of length ${bytes.length} to 32`
+    );
+  }
+  const out = new Uint8Array(32);
+  out.set(bytes, 32 - bytes.length);
+  return out;
+}
+function padRight32(bytes) {
+  const padded = Math.ceil(bytes.length / 32) * 32;
+  const out = new Uint8Array(padded);
+  out.set(bytes, 0);
+  return out;
+}
+function encodeUpdateBalanceCallData(channelIdBytes, cumulativeAmount, nonce, recipientBytes, signature) {
+  if (channelIdBytes.length !== 32) {
+    throw new SettlementTxError(
+      "ENCODING_FAILED",
+      `channelId must be 32 bytes (got ${channelIdBytes.length})`
+    );
+  }
+  if (recipientBytes.length !== 20) {
+    throw new SettlementTxError(
+      "ENCODING_FAILED",
+      `recipient must be 20 bytes (got ${recipientBytes.length})`
+    );
+  }
+  const channelIdWord = channelIdBytes;
+  const cumulativeWord = bigintToBytes32BE(cumulativeAmount);
+  const nonceWord = bigintToBytes32BE(nonce);
+  const recipientWord = padLeft32(recipientBytes);
+  const offsetWord = bigintToBytes32BE(160n);
+  const sigLenWord = bigintToBytes32BE(BigInt(signature.length));
+  const sigPadded = padRight32(signature);
+  return concatBytes(
+    EVM_SETTLEMENT_FUNCTION_SELECTOR,
+    channelIdWord,
+    cumulativeWord,
+    nonceWord,
+    recipientWord,
+    offsetWord,
+    sigLenWord,
+    sigPadded
+  );
+}
+function rlpEncodeBytes(bytes) {
+  if (bytes.length === 1 && bytes[0] !== void 0 && bytes[0] < 128) {
+    return bytes;
+  }
+  if (bytes.length < 56) {
+    return concatBytes(new Uint8Array([128 + bytes.length]), bytes);
+  }
+  const lenBytes = bigintToMinimalBytes(BigInt(bytes.length));
+  return concatBytes(new Uint8Array([183 + lenBytes.length]), lenBytes, bytes);
+}
+function rlpEncodeList(items) {
+  const payload = concatBytes(...items);
+  if (payload.length < 56) {
+    return concatBytes(new Uint8Array([192 + payload.length]), payload);
+  }
+  const lenBytes = bigintToMinimalBytes(BigInt(payload.length));
+  return concatBytes(
+    new Uint8Array([247 + lenBytes.length]),
+    lenBytes,
+    payload
+  );
+}
+function bigintToMinimalBytes(x) {
+  if (x < 0n) {
+    throw new SettlementTxError(
+      "ENCODING_FAILED",
+      "bigintToMinimalBytes: negative input"
+    );
+  }
+  if (x === 0n) return new Uint8Array(0);
+  let hex = x.toString(16);
+  if (hex.length % 2) hex = "0" + hex;
+  const out = new Uint8Array(hex.length / 2);
+  for (let i = 0; i < out.length; i++) {
+    out[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+  }
+  return out;
+}
+function rlpEncodeUint(x) {
+  return rlpEncodeBytes(bigintToMinimalBytes(x));
+}
+function rlpEncodeUnsignedTx(params) {
+  return rlpEncodeList([
+    rlpEncodeUint(params.nonce),
+    rlpEncodeUint(params.gasPrice),
+    rlpEncodeUint(params.gasLimit),
+    rlpEncodeBytes(params.to),
+    rlpEncodeUint(params.value),
+    rlpEncodeBytes(params.data),
+    rlpEncodeUint(params.chainId),
+    rlpEncodeUint(0n),
+    rlpEncodeUint(0n)
+  ]);
+}
+function buildEvmSettlementTx(winner, signer, recipient, selectedClaimIndex, claimsMerged) {
+  if (winner.channelId === void 0 || winner.cumulativeAmount === void 0 || winner.nonce === void 0 || winner.recipient === void 0 || winner.millSignerAddress === void 0) {
+    throw new SettlementTxError(
+      "MISSING_SETTLEMENT_METADATA",
+      "EVM winner claim missing settlement-context fields"
+    );
+  }
+  if (!signer.contractAddress) {
+    throw new SettlementTxError(
+      "INVALID_INPUT",
+      `EVM MillSignerConfig.contractAddress is required for chain ${winner.pair.to.chain}`
+    );
+  }
+  if (typeof signer.chainId !== "number" || !Number.isInteger(signer.chainId) || signer.chainId <= 0) {
+    throw new SettlementTxError(
+      "INVALID_INPUT",
+      `EVM MillSignerConfig.chainId must be a positive integer, got ${signer.chainId}`
+    );
+  }
+  const channelIdBytes = hexToBytes2(winner.channelId);
+  const recipientBytes = hexToBytes2(recipient);
+  const contractBytes = hexToBytes2(signer.contractAddress);
+  const calldata = encodeUpdateBalanceCallData(
+    channelIdBytes,
+    BigInt(winner.cumulativeAmount),
+    BigInt(winner.nonce),
+    recipientBytes,
+    winner.claimBytes
+  );
+  const unsignedTxBytes = rlpEncodeUnsignedTx({
+    nonce: 0n,
+    gasPrice: 0n,
+    gasLimit: 0n,
+    to: contractBytes,
+    value: 0n,
+    data: calldata,
+    chainId: BigInt(signer.chainId)
+  });
+  return {
+    chain: winner.pair.to.chain,
+    chainKind: "evm",
+    channelId: winner.channelId,
+    cumulativeAmount: winner.cumulativeAmount,
+    nonce: winner.nonce,
+    recipient,
+    millSignerAddress: winner.millSignerAddress,
+    unsignedTxBytes,
+    expectedEventSignature: EVM_SETTLEMENT_EVENT_TOPIC,
+    claimsMerged,
+    selectedClaimIndex,
+    sourceChain: winner.pair.from.chain,
+    sourceAssetCode: winner.pair.from.assetCode
+  };
+}
+function fillEvmSettlementTxGas(bundle, gas, signer) {
+  if (bundle.chainKind !== "evm") {
+    throw new SettlementTxError(
+      "UNSUPPORTED_CHAIN",
+      `fillEvmSettlementTxGas requires chainKind=evm, got ${bundle.chainKind}`
+    );
+  }
+  if (!signer.contractAddress) {
+    throw new SettlementTxError(
+      "INVALID_INPUT",
+      "EVM MillSignerConfig.contractAddress is required for gas-fill"
+    );
+  }
+  if (typeof signer.chainId !== "number" || signer.chainId <= 0) {
+    throw new SettlementTxError(
+      "INVALID_INPUT",
+      "EVM MillSignerConfig.chainId must be a positive integer"
+    );
+  }
+  const channelIdBytes = hexToBytes2(bundle.channelId);
+  const recipientBytes = hexToBytes2(bundle.recipient);
+  const contractBytes = hexToBytes2(signer.contractAddress);
+  const sig = extractSignatureFromBundle(bundle);
+  const calldata = encodeUpdateBalanceCallData(
+    channelIdBytes,
+    BigInt(bundle.cumulativeAmount),
+    BigInt(bundle.nonce),
+    recipientBytes,
+    sig
+  );
+  return rlpEncodeUnsignedTx({
+    nonce: gas.nonce,
+    gasPrice: gas.gasPrice,
+    gasLimit: gas.gasLimit,
+    to: contractBytes,
+    value: 0n,
+    data: calldata,
+    chainId: BigInt(signer.chainId)
+  });
+}
+function extractSignatureFromBundle(bundle) {
+  const tx = bundle.unsignedTxBytes;
+  const list = rlpDecodeList(tx);
+  if (list.length < 6) {
+    throw new SettlementTxError(
+      "ENCODING_FAILED",
+      "unsignedTxBytes is not a 9-element RLP list"
+    );
+  }
+  const data = list[5];
+  if (!data) {
+    throw new SettlementTxError(
+      "ENCODING_FAILED",
+      "unsignedTxBytes missing data field"
+    );
+  }
+  const sigLenOffset = 4 + 5 * 32;
+  if (data.length < sigLenOffset + 32) {
+    throw new SettlementTxError(
+      "ENCODING_FAILED",
+      "calldata too short to contain signature length word"
+    );
+  }
+  const sigLenBytes = data.slice(sigLenOffset, sigLenOffset + 32);
+  let sigLen = 0n;
+  for (const b of sigLenBytes) sigLen = sigLen << 8n | BigInt(b);
+  const sigStart = sigLenOffset + 32;
+  const sigEnd = sigStart + Number(sigLen);
+  if (sigEnd > data.length) {
+    throw new SettlementTxError(
+      "ENCODING_FAILED",
+      "calldata truncated before end of signature bytes"
+    );
+  }
+  return data.slice(sigStart, sigEnd);
+}
+function rlpDecodeList(buf) {
+  if (buf.length === 0) {
+    throw new SettlementTxError("ENCODING_FAILED", "empty RLP input");
+  }
+  const first = buf[0] ?? 0;
+  let offset;
+  let listEnd;
+  if (first >= 192 && first <= 247) {
+    offset = 1;
+    listEnd = 1 + (first - 192);
+  } else if (first >= 248 && first <= 255) {
+    const lenOfLen = first - 247;
+    let listLen = 0;
+    for (let i = 0; i < lenOfLen; i++) {
+      listLen = listLen << 8 | (buf[1 + i] ?? 0);
+    }
+    offset = 1 + lenOfLen;
+    listEnd = offset + listLen;
+  } else {
+    throw new SettlementTxError(
+      "ENCODING_FAILED",
+      `rlpDecodeList: input is not a list (first byte 0x${first.toString(16)})`
+    );
+  }
+  const items = [];
+  let p = offset;
+  while (p < listEnd) {
+    const b = buf[p] ?? 0;
+    if (b < 128) {
+      items.push(buf.slice(p, p + 1));
+      p += 1;
+    } else if (b <= 183) {
+      const len = b - 128;
+      items.push(buf.slice(p + 1, p + 1 + len));
+      p += 1 + len;
+    } else if (b <= 191) {
+      const lenOfLen = b - 183;
+      let len = 0;
+      for (let i = 0; i < lenOfLen; i++) {
+        len = len << 8 | (buf[p + 1 + i] ?? 0);
+      }
+      items.push(buf.slice(p + 1 + lenOfLen, p + 1 + lenOfLen + len));
+      p += 1 + lenOfLen + len;
+    } else {
+      throw new SettlementTxError(
+        "ENCODING_FAILED",
+        "rlpDecodeList: nested list not supported in minimal decoder"
+      );
+    }
+  }
+  return items;
+}
+function verifyEvmClaimSignature(claim, expectedAddress) {
+  const recovered = recoverEvmSignerAddress(claim);
+  const expected = expectedAddress.toLowerCase();
+  return {
+    valid: recovered.toLowerCase() === expected,
+    recovered
+  };
+}
+
+// src/settlement/mina.ts
+var MINA_NETWORK = "mainnet";
+async function loadMinaSignerClient() {
+  try {
+    const lib = await import("mina-signer");
+    const Ctor = "default" in lib ? lib.default : lib;
+    return new Ctor({ network: MINA_NETWORK });
+  } catch {
+    return void 0;
+  }
+}
+function verifyMinaSignature(claim, expectedSignerAddress, client) {
+  if (claim.channelId === void 0 || claim.cumulativeAmount === void 0 || claim.nonce === void 0 || claim.recipient === void 0) {
+    throw new SettlementTxError(
+      "MISSING_SETTLEMENT_METADATA",
+      "Claim missing channelId/cumulativeAmount/nonce/recipient for Mina signature verify"
+    );
+  }
+  if (claim.claimBytes.length === 0) {
+    throw new SettlementTxError(
+      "INVALID_SIGNATURE_LENGTH",
+      "Mina claimBytes is empty (expected UTF-8 base58 signature string)"
+    );
+  }
+  const signature = new TextDecoder().decode(claim.claimBytes);
+  const fields = balanceProofFieldsMina(
+    claim.channelId,
+    BigInt(claim.cumulativeAmount),
+    BigInt(claim.nonce),
+    claim.recipient
+  );
+  try {
+    return client.verifyFields({
+      data: fields,
+      signature,
+      publicKey: expectedSignerAddress
+    });
+  } catch {
+    return false;
+  }
+}
+function buildMinaSettlementTx(winner, signer, recipient, selectedClaimIndex, claimsMerged) {
+  if (winner.channelId === void 0 || winner.cumulativeAmount === void 0 || winner.nonce === void 0 || winner.recipient === void 0 || winner.millSignerAddress === void 0) {
+    throw new SettlementTxError(
+      "MISSING_SETTLEMENT_METADATA",
+      "Mina winner claim missing settlement-context fields"
+    );
+  }
+  if (!signer.address) {
+    throw new SettlementTxError(
+      "INVALID_INPUT",
+      `Mina MillSignerConfig.address is required for chain ${winner.pair.to.chain}`
+    );
+  }
+  if (winner.claimBytes.length === 0) {
+    throw new SettlementTxError(
+      "INVALID_SIGNATURE_LENGTH",
+      "Mina winner claimBytes is empty (expected UTF-8 base58 signature string)"
+    );
+  }
+  const unsignedTxBytes = winner.claimBytes;
+  return {
+    chain: winner.pair.to.chain,
+    chainKind: "mina",
+    channelId: winner.channelId,
+    cumulativeAmount: winner.cumulativeAmount,
+    nonce: winner.nonce,
+    recipient,
+    millSignerAddress: winner.millSignerAddress,
+    unsignedTxBytes,
+    claimsMerged,
+    selectedClaimIndex,
+    sourceChain: winner.pair.from.chain,
+    sourceAssetCode: winner.pair.from.assetCode
+  };
+}
+
+// src/settlement/solana.ts
+import { ed25519 } from "@noble/curves/ed25519.js";
+import { sha256 } from "@noble/hashes/sha2.js";
+function verifyEd25519Signature(claim, expectedSignerAddress) {
+  if (claim.channelId === void 0 || claim.cumulativeAmount === void 0 || claim.nonce === void 0 || claim.recipient === void 0) {
+    throw new SettlementTxError(
+      "MISSING_SETTLEMENT_METADATA",
+      "Claim missing channelId/cumulativeAmount/nonce/recipient for Solana signature verify"
+    );
+  }
+  if (claim.claimBytes.length !== 64) {
+    throw new SettlementTxError(
+      "INVALID_SIGNATURE_LENGTH",
+      `Solana signature must be 64 bytes, got ${claim.claimBytes.length}`
+    );
+  }
+  const msgHash = balanceProofHashSolana(
+    claim.channelId,
+    BigInt(claim.cumulativeAmount),
+    BigInt(claim.nonce),
+    claim.recipient
+  );
+  let pubkeyBytes;
+  try {
+    pubkeyBytes = base58Decode(expectedSignerAddress);
+  } catch (err) {
+    throw new SettlementTxError(
+      "INVALID_INPUT",
+      `Solana expected signer address is not valid base58: ${expectedSignerAddress}`,
+      { cause: err }
+    );
+  }
+  if (pubkeyBytes.length !== 32) {
+    throw new SettlementTxError(
+      "INVALID_INPUT",
+      `Solana expected signer pubkey must be 32 bytes, got ${pubkeyBytes.length}`
+    );
+  }
+  try {
+    return ed25519.verify(claim.claimBytes, msgHash, pubkeyBytes);
+  } catch {
+    return false;
+  }
+}
+var SOLANA_UPDATE_BALANCE_DISCRIMINATOR = sha256(
+  new TextEncoder().encode("global:update_balance")
+).slice(0, 8);
+function bigintToBytes8LE(x) {
+  if (x < 0n) {
+    throw new SettlementTxError(
+      "ENCODING_FAILED",
+      "bigintToBytes8LE: negative input"
+    );
+  }
+  if (x > 0xffffffffffffffffn) {
+    throw new SettlementTxError(
+      "ENCODING_FAILED",
+      "bigintToBytes8LE: value exceeds 64 bits"
+    );
+  }
+  const out = new Uint8Array(8);
+  let v = x;
+  for (let i = 0; i < 8; i++) {
+    out[i] = Number(v & 0xffn);
+    v >>= 8n;
+  }
+  return out;
+}
+function buildSolanaSettlementTx(winner, signer, recipient, selectedClaimIndex, claimsMerged) {
+  if (winner.channelId === void 0 || winner.cumulativeAmount === void 0 || winner.nonce === void 0 || winner.recipient === void 0 || winner.millSignerAddress === void 0) {
+    throw new SettlementTxError(
+      "MISSING_SETTLEMENT_METADATA",
+      "Solana winner claim missing settlement-context fields"
+    );
+  }
+  if (!signer.programId) {
+    throw new SettlementTxError(
+      "INVALID_INPUT",
+      `Solana MillSignerConfig.programId is required for chain ${winner.pair.to.chain}`
+    );
+  }
+  let programIdBytes;
+  let recipientBytes;
+  let millBytes;
+  let channelIdBytes;
+  try {
+    programIdBytes = base58Decode(signer.programId);
+    recipientBytes = base58Decode(recipient);
+    millBytes = base58Decode(winner.millSignerAddress);
+    channelIdBytes = base58Decode(winner.channelId);
+  } catch (err) {
+    throw new SettlementTxError(
+      "ENCODING_FAILED",
+      `Solana settlement tx: base58 decode failed (${err instanceof Error ? err.message : String(err)})`,
+      { cause: err }
+    );
+  }
+  if (programIdBytes.length !== 32) {
+    throw new SettlementTxError(
+      "INVALID_INPUT",
+      `Solana programId must be 32 bytes, got ${programIdBytes.length}`
+    );
+  }
+  if (recipientBytes.length !== 32) {
+    throw new SettlementTxError(
+      "INVALID_INPUT",
+      `Solana recipient must decode to 32 bytes, got ${recipientBytes.length}`
+    );
+  }
+  if (millBytes.length !== 32) {
+    throw new SettlementTxError(
+      "INVALID_INPUT",
+      `Solana millSignerAddress must decode to 32 bytes, got ${millBytes.length}`
+    );
+  }
+  if (channelIdBytes.length !== 32) {
+    throw new SettlementTxError(
+      "INVALID_INPUT",
+      `Solana channelId must decode to 32 bytes, got ${channelIdBytes.length}`
+    );
+  }
+  const instructionData = concatBytes(
+    SOLANA_UPDATE_BALANCE_DISCRIMINATOR,
+    bigintToBytes8LE(BigInt(winner.cumulativeAmount)),
+    bigintToBytes8LE(BigInt(winner.nonce)),
+    winner.claimBytes
+  );
+  const accounts = [recipientBytes, millBytes, channelIdBytes, programIdBytes];
+  const header = new Uint8Array([1, 0, 1]);
+  const accountsCountByte = new Uint8Array([accounts.length]);
+  const recentBlockhash = new Uint8Array(32);
+  const instructionsCountByte = new Uint8Array([1]);
+  const programIdIndex = new Uint8Array([3]);
+  const instrAccountsLen = new Uint8Array([3]);
+  const instrAccountIndices = new Uint8Array([0, 1, 2]);
+  if (instructionData.length >= 128) {
+    throw new SettlementTxError(
+      "ENCODING_FAILED",
+      `Solana instruction data too large for simple compact-u16 encoding: ${instructionData.length}`
+    );
+  }
+  const instrDataLen = new Uint8Array([instructionData.length]);
+  const instruction = concatBytes(
+    programIdIndex,
+    instrAccountsLen,
+    instrAccountIndices,
+    instrDataLen,
+    instructionData
+  );
+  const unsignedTxBytes = concatBytes(
+    header,
+    accountsCountByte,
+    ...accounts,
+    recentBlockhash,
+    instructionsCountByte,
+    instruction
+  );
+  return {
+    chain: winner.pair.to.chain,
+    chainKind: "solana",
+    channelId: winner.channelId,
+    cumulativeAmount: winner.cumulativeAmount,
+    nonce: winner.nonce,
+    recipient,
+    millSignerAddress: winner.millSignerAddress,
+    unsignedTxBytes,
+    claimsMerged,
+    selectedClaimIndex,
+    sourceChain: winner.pair.from.chain,
+    sourceAssetCode: winner.pair.from.assetCode
+  };
+}
+
+// src/settlement/build-settlement-tx.ts
+var EVM_ADDRESS_REGEX = /^0x[0-9a-f]{40}$/;
+function chainKindOf(chain) {
+  if (chain.startsWith("evm:")) return "evm";
+  if (chain.startsWith("solana:")) return "solana";
+  if (chain.startsWith("mina:")) return "mina";
+  return "unknown";
+}
+function buildSettlementTx(params) {
+  if (!Array.isArray(params.claims) || params.claims.length === 0) {
+    throw new SettlementTxError(
+      "INVALID_INPUT",
+      "claims array is empty or not an array"
+    );
+  }
+  if (!params.signers || typeof params.signers !== "object") {
+    throw new SettlementTxError("INVALID_INPUT", "signers map is required");
+  }
+  if (!params.recipients || typeof params.recipients !== "object") {
+    throw new SettlementTxError("INVALID_INPUT", "recipients map is required");
+  }
+  const logger = params.logger;
+  const verifySignatures = params.verifySignatures ?? true;
+  for (let i = 0; i < params.claims.length; i++) {
+    const c = params.claims[i];
+    if (c === void 0) continue;
+    if (c.channelId === void 0 || c.nonce === void 0 || c.cumulativeAmount === void 0 || c.recipient === void 0 || c.millSignerAddress === void 0) {
+      throw new SettlementTxError(
+        "MISSING_SETTLEMENT_METADATA",
+        `claims[${i}] missing one or more of { channelId, nonce, cumulativeAmount, recipient, millSignerAddress }`
+      );
+    }
+  }
+  const distinctChains = /* @__PURE__ */ new Set();
+  for (const c of params.claims) distinctChains.add(c.pair.to.chain);
+  for (const chain of distinctChains) {
+    const signer = params.signers[chain];
+    if (!signer) {
+      throw new SettlementTxError(
+        "UNSUPPORTED_CHAIN",
+        `signers map missing entry for chain ${chain}`
+      );
+    }
+    if (!(chain in params.recipients)) {
+      throw new SettlementTxError(
+        "MISSING_RECIPIENT",
+        `recipients map missing entry for chain ${chain}`
+      );
+    }
+    const kind = chainKindOf(chain);
+    if (kind === "evm") {
+      if (!signer.contractAddress || !EVM_ADDRESS_REGEX.test(signer.contractAddress)) {
+        throw new SettlementTxError(
+          "INVALID_INPUT",
+          `EVM signers[${chain}].contractAddress must match 0x + 40 lowercase hex`
+        );
+      }
+      if (typeof signer.chainId !== "number" || !Number.isInteger(signer.chainId) || signer.chainId <= 0) {
+        throw new SettlementTxError(
+          "INVALID_INPUT",
+          `EVM signers[${chain}].chainId must be a positive integer`
+        );
+      }
+    } else if (kind === "solana") {
+      if (!signer.programId || signer.programId.length === 0) {
+        throw new SettlementTxError(
+          "INVALID_INPUT",
+          `Solana signers[${chain}].programId is required`
+        );
+      }
+      let programIdLen;
+      try {
+        programIdLen = base58Decode(signer.programId).length;
+      } catch (err) {
+        throw new SettlementTxError(
+          "INVALID_INPUT",
+          `Solana signers[${chain}].programId is not valid base58`,
+          { cause: err }
+        );
+      }
+      if (programIdLen !== 32) {
+        throw new SettlementTxError(
+          "INVALID_INPUT",
+          `Solana signers[${chain}].programId must decode to 32 bytes (got ${programIdLen})`
+        );
+      }
+    }
+  }
+  const rejected = [];
+  const survivors = [];
+  for (const claim of params.claims) {
+    if (!verifySignatures) {
+      survivors.push(claim);
+      continue;
+    }
+    const chain = claim.pair.to.chain;
+    const signer = params.signers[chain];
+    if (!signer) {
+      throw new SettlementTxError(
+        "UNSUPPORTED_CHAIN",
+        `signers map missing entry for chain ${chain} (unreachable \u2014 validated)`
+      );
+    }
+    const kind = chainKindOf(chain);
+    if (kind === "evm") {
+      try {
+        const { valid, recovered } = verifyEvmClaimSignature(
+          claim,
+          signer.address
+        );
+        if (!valid) {
+          rejected.push({
+            claim,
+            reason: "SIGNER_MISMATCH",
+            details: `recovered=${recovered} expected=${signer.address.toLowerCase()}`
+          });
+          continue;
+        }
+        survivors.push(claim);
+      } catch (err) {
+        rejected.push({
+          claim,
+          reason: "SIGNATURE_INVALID",
+          details: err instanceof Error ? err.message : String(err)
+        });
+      }
+    } else if (kind === "solana") {
+      try {
+        const ok = verifyEd25519Signature(claim, signer.address);
+        if (!ok) {
+          rejected.push({
+            claim,
+            reason: "SIGNER_MISMATCH",
+            details: `ed25519.verify returned false against ${signer.address}`
+          });
+          continue;
+        }
+        survivors.push(claim);
+      } catch (err) {
+        rejected.push({
+          claim,
+          reason: "SIGNATURE_INVALID",
+          details: err instanceof Error ? err.message : String(err)
+        });
+      }
+    } else if (kind === "mina") {
+      if (!params.minaSignerClient) {
+        rejected.push({
+          claim,
+          reason: "MINA_VERIFICATION_UNSUPPORTED",
+          details: "minaSignerClient not provided \u2014 load mina-signer via loadMinaSignerClient() and pass it in params.minaSignerClient to verify mina:* claims"
+        });
+        continue;
+      }
+      try {
+        const ok = verifyMinaSignature(
+          claim,
+          signer.address,
+          params.minaSignerClient
+        );
+        if (!ok) {
+          rejected.push({
+            claim,
+            reason: "SIGNER_MISMATCH",
+            details: `mina-signer verifyFields returned false against ${signer.address}`
+          });
+          continue;
+        }
+        survivors.push(claim);
+      } catch (err) {
+        rejected.push({
+          claim,
+          reason: "SIGNATURE_INVALID",
+          details: err instanceof Error ? err.message : String(err)
+        });
+      }
+    } else {
+      throw new SettlementTxError(
+        "UNSUPPORTED_CHAIN",
+        `Unknown chain kind for ${chain}`
+      );
+    }
+  }
+  logger?.debug?.({
+    event: "build_settlement_tx.verified",
+    survivorCount: survivors.length,
+    rejectedCount: rejected.length
+  });
+  const groups = /* @__PURE__ */ new Map();
+  const originalIndex = /* @__PURE__ */ new Map();
+  for (let i = 0; i < params.claims.length; i++) {
+    const c = params.claims[i];
+    if (c !== void 0) originalIndex.set(c, i);
+  }
+  for (const claim of survivors) {
+    const chain = claim.pair.to.chain;
+    const channelId = claim.channelId;
+    if (channelId === void 0) {
+      throw new SettlementTxError(
+        "MISSING_SETTLEMENT_METADATA",
+        "claim.channelId undefined after validation (unreachable)"
+      );
+    }
+    const key = `${chain}::${channelId}`;
+    let g = groups.get(key);
+    if (!g) {
+      g = { chain, channelId, claims: [] };
+      groups.set(key, g);
+    }
+    const idx = originalIndex.get(claim);
+    g.claims.push({ claim, originalIndex: idx ?? -1 });
+  }
+  const superseded = [];
+  const bundles = [];
+  for (const g of groups.values()) {
+    if (g.claims.length === 0) continue;
+    const first = g.claims[0];
+    if (!first) continue;
+    const firstRecipient = first.claim.recipient;
+    const firstMillSigner = first.claim.millSignerAddress;
+    if (firstRecipient === void 0 || firstMillSigner === void 0) {
+      throw new SettlementTxError(
+        "MISSING_SETTLEMENT_METADATA",
+        "winner claim missing recipient/millSignerAddress (unreachable after validation)"
+      );
+    }
+    for (let i = 1; i < g.claims.length; i++) {
+      const entry = g.claims[i];
+      if (!entry) continue;
+      const c = entry.claim;
+      if (c.recipient !== firstRecipient) {
+        throw new SettlementTxError(
+          "RECIPIENT_MISMATCH",
+          `claims in channel ${g.channelId} disagree on recipient: ${firstRecipient} vs ${String(c.recipient)} (claim indices ${first.originalIndex}, ${entry.originalIndex})`
+        );
+      }
+      if (c.millSignerAddress !== firstMillSigner) {
+        throw new SettlementTxError(
+          "MILL_SIGNER_MISMATCH",
+          `claims in channel ${g.channelId} disagree on millSignerAddress: ${firstMillSigner} vs ${String(c.millSignerAddress)}`
+        );
+      }
+    }
+    const nonceSeen = /* @__PURE__ */ new Set();
+    for (const entry of g.claims) {
+      const nonceStr = entry.claim.nonce;
+      if (nonceStr === void 0) {
+        throw new SettlementTxError(
+          "MISSING_SETTLEMENT_METADATA",
+          "claim.nonce undefined (unreachable after validation)"
+        );
+      }
+      if (nonceSeen.has(nonceStr)) {
+        throw new SettlementTxError(
+          "DUPLICATE_NONCE",
+          `channel ${g.channelId} has two claims with nonce ${nonceStr}`
+        );
+      }
+      nonceSeen.add(nonceStr);
+    }
+    const sorted = [...g.claims].sort((a, b) => {
+      const an = BigInt(a.claim.nonce ?? "0");
+      const bn = BigInt(b.claim.nonce ?? "0");
+      return an < bn ? -1 : an > bn ? 1 : 0;
+    });
+    for (let i = 1; i < sorted.length; i++) {
+      const prevE = sorted[i - 1];
+      const currE = sorted[i];
+      if (!prevE || !currE) continue;
+      const prev = BigInt(prevE.claim.cumulativeAmount ?? "0");
+      const curr = BigInt(currE.claim.cumulativeAmount ?? "0");
+      if (curr < prev) {
+        throw new SettlementTxError(
+          "NON_MONOTONIC_CUMULATIVE",
+          `channel ${g.channelId} nonce ${String(currE.claim.nonce)} has cumulativeAmount ${curr} < previous nonce ${String(prevE.claim.nonce)} cumulativeAmount ${prev}`
+        );
+      }
+    }
+    const winnerEntry = sorted[sorted.length - 1];
+    if (!winnerEntry) continue;
+    const winner = winnerEntry.claim;
+    if (params.includeSuperseded) {
+      for (let i = 0; i < sorted.length - 1; i++) {
+        const e = sorted[i];
+        if (e) superseded.push(e.claim);
+      }
+    }
+    const signer = params.signers[g.chain];
+    const recipient = params.recipients[g.chain];
+    if (!signer || recipient === void 0) {
+      throw new SettlementTxError(
+        "UNSUPPORTED_CHAIN",
+        `signers/recipients missing entry for ${g.chain} (unreachable after validation)`
+      );
+    }
+    const kind = chainKindOf(g.chain);
+    let bundle;
+    if (kind === "evm") {
+      if (recipient.toLowerCase() !== firstRecipient.toLowerCase()) {
+        throw new SettlementTxError(
+          "RECIPIENT_MISMATCH",
+          `recipients[${g.chain}] (${recipient}) does not match Mill-reported recipient (${firstRecipient})`
+        );
+      }
+      bundle = buildEvmSettlementTx(
+        winner,
+        signer,
+        recipient.toLowerCase(),
+        winnerEntry.originalIndex,
+        g.claims.length
+      );
+    } else if (kind === "solana") {
+      if (recipient !== firstRecipient) {
+        throw new SettlementTxError(
+          "RECIPIENT_MISMATCH",
+          `recipients[${g.chain}] (${recipient}) does not match Mill-reported recipient (${firstRecipient})`
+        );
+      }
+      bundle = buildSolanaSettlementTx(
+        winner,
+        signer,
+        recipient,
+        winnerEntry.originalIndex,
+        g.claims.length
+      );
+    } else if (kind === "mina") {
+      if (recipient !== firstRecipient) {
+        throw new SettlementTxError(
+          "RECIPIENT_MISMATCH",
+          `recipients[${g.chain}] (${recipient}) does not match Mill-reported recipient (${firstRecipient})`
+        );
+      }
+      bundle = buildMinaSettlementTx(
+        winner,
+        signer,
+        recipient,
+        winnerEntry.originalIndex,
+        g.claims.length
+      );
+    } else {
+      throw new SettlementTxError(
+        "UNSUPPORTED_CHAIN",
+        `Unknown chain kind for ${g.chain}`
+      );
+    }
+    bundles.push(bundle);
+  }
+  logger?.info?.({
+    event: "build_settlement_tx.complete",
+    bundleCount: bundles.length,
+    rejectedCount: rejected.length,
+    supersededCount: superseded.length
+  });
+  return { bundles, rejected, superseded };
+}
+function verifyAccumulatedClaim(claim, signer, minaSignerClient) {
+  const kind = chainKindOf(claim.pair.to.chain);
+  if (kind === "evm") {
+    try {
+      const { valid, recovered } = verifyEvmClaimSignature(
+        claim,
+        signer.address
+      );
+      if (valid) return { valid: true };
+      return {
+        valid: false,
+        reason: `SIGNER_MISMATCH: recovered=${recovered} expected=${signer.address.toLowerCase()}`
+      };
+    } catch (err) {
+      return {
+        valid: false,
+        reason: `SIGNATURE_INVALID: ${err instanceof Error ? err.message : String(err)}`
+      };
+    }
+  }
+  if (kind === "solana") {
+    try {
+      const ok = verifyEd25519Signature(claim, signer.address);
+      return ok ? { valid: true } : {
+        valid: false,
+        reason: "SIGNER_MISMATCH: ed25519.verify returned false"
+      };
+    } catch (err) {
+      return {
+        valid: false,
+        reason: `SIGNATURE_INVALID: ${err instanceof Error ? err.message : String(err)}`
+      };
+    }
+  }
+  if (kind === "mina") {
+    if (!minaSignerClient) {
+      return {
+        valid: false,
+        reason: "MINA_VERIFICATION_UNSUPPORTED: pass a mina-signer Client (loadMinaSignerClient()) as minaSignerClient to verify mina:* claims"
+      };
+    }
+    try {
+      const ok = verifyMinaSignature(claim, signer.address, minaSignerClient);
+      return ok ? { valid: true } : {
+        valid: false,
+        reason: "SIGNER_MISMATCH: mina-signer verifyFields returned false"
+      };
+    } catch (err) {
+      return {
+        valid: false,
+        reason: `SIGNATURE_INVALID: ${err instanceof Error ? err.message : String(err)}`
+      };
+    }
+  }
+  return {
+    valid: false,
+    reason: `UNSUPPORTED_CHAIN: ${claim.pair.to.chain}`
+  };
+}
 export {
   ChunkManager,
+  GiftWrapError,
   HandlerError,
   HandlerRegistry,
   IdentityError,
   NodeError,
   PricingError,
+  SWAP_HANDLER_REJECT_CODES,
+  SWAP_HANDLER_REJECT_MESSAGES,
+  SettlementTxError,
+  StreamSwapError,
+  SwapHandlerError,
   SwarmCoordinator,
   TurboUploadAdapter,
   VerificationError,
   WorkflowOrchestrator,
+  __testing as __streamSwapTesting,
+  applyRate,
+  balanceProofFieldsMina,
+  balanceProofHashEvm,
+  balanceProofHashSolana,
+  base58Decode,
+  base58Encode,
+  bigintToBytes32BE,
+  buildSettlementTx,
   buildSkillDescriptor,
+  concatBytes,
   createArweaveDvmHandler,
   createEventStorageHandler,
   createHandlerContext,
@@ -2081,11 +3071,30 @@ export {
   createPaymentHandlerBridge,
   createPrefixClaimHandler,
   createPricingValidator,
+  createSwapHandler,
   createVerificationPipeline,
+  decryptFulfillClaim,
+  encryptFulfillClaim,
+  fillEvmSettlementTxGas,
+  findSwapPair,
   fromMnemonic,
+  fromMnemonicFull,
   fromSecretKey,
   generateMnemonic,
+  generateSolanaKeypair,
+  hexToBytes2 as hexToBytes,
+  loadMinaSignerClient,
+  minaHashToField,
+  streamSwap,
+  streamSwapControlled,
+  unwrapSwapPacket,
+  unwrapSwapPacketFromToon,
   uploadBlob,
-  uploadBlobChunked
+  uploadBlobChunked,
+  verifyAccumulatedClaim,
+  verifyEd25519Signature,
+  verifyMinaSignature,
+  wrapSwapPacket,
+  wrapSwapPacketToToon
 };
 //# sourceMappingURL=index.js.map