@toon-protocol/client 0.16.0 → 0.18.0

package/dist/index.js

@@ -153,7 +153,7 @@ async function deriveSolanaKey(seed, accountIndex = 0) {
   const { ed25519: ed255194 } = await import("@noble/curves/ed25519.js");
   const encoder = new TextEncoder();
   let I = hmac(sha512, encoder.encode("ed25519 seed"), seed);
-  let key = I.slice(0, 32);
+  let key2 = I.slice(0, 32);
   let chainCode = I.slice(32);
   const indices = [
     2147483692,
@@ -168,18 +168,18 @@ async function deriveSolanaKey(seed, accountIndex = 0) {
   for (const index of indices) {
     const data = new Uint8Array(37);
     data[0] = 0;
-    data.set(key, 1);
+    data.set(key2, 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);
+    key2 = I.slice(0, 32);
     chainCode = I.slice(32);
   }
-  const publicKeyBytes = ed255194.getPublicKey(key);
+  const publicKeyBytes = ed255194.getPublicKey(key2);
   const keypair = new Uint8Array(64);
-  keypair.set(key, 0);
+  keypair.set(key2, 0);
   keypair.set(publicKeyBytes, 32);
   const publicKey = toBase58(publicKeyBytes);
   return { secretKey: keypair, publicKey };
@@ -894,9 +894,13 @@ function deserializeIlpPacket(buf) {
 }
 function deserializeIlpFulfill(buf) {
   let offset = 1;
+  if (buf.length < offset + 32) {
+    throw new Error("Buffer underflow reading FULFILL fulfillment");
+  }
+  const fulfillment = buf.slice(offset, offset + 32);
   offset += 32;
   const { value: data } = decodeVarOctetString(buf, offset);
-  return { type: ILPPacketType.FULFILL, data };
+  return { type: ILPPacketType.FULFILL, fulfillment, data };
 }
 function deserializeIlpReject(buf) {
   let offset = 1;
@@ -1207,8 +1211,10 @@ var IsomorphicBtpClient = class {
             this.pendingRequests.delete(id);
             if (json["type"] === "FULFILL") {
               const responseData = json["data"] ? this.base64ToUint8Array(json["data"]) : new Uint8Array(0);
+              const fulfillment = json["fulfillment"] ? this.base64ToUint8Array(json["fulfillment"]) : new Uint8Array(32);
               pending.resolve({
                 type: ILPPacketType.FULFILL,
+                fulfillment,
                 data: responseData
               });
             } else {
@@ -1269,6 +1275,74 @@ var IsomorphicBtpClient = class {
   }
 };
 
+// src/utils/condition.ts
+import { sha256 } from "@noble/hashes/sha2.js";
+import { randomBytes } from "@noble/hashes/utils.js";
+var CONDITION_LENGTH = 32;
+function mintExecutionCondition() {
+  const preimage = randomBytes(CONDITION_LENGTH);
+  return { preimage, condition: sha256(preimage) };
+}
+function isZeroCondition(condition) {
+  if (condition === void 0) return true;
+  for (const byte of condition) {
+    if (byte !== 0) return false;
+  }
+  return true;
+}
+function assertValidCondition(condition) {
+  if (condition.length !== CONDITION_LENGTH) {
+    throw new Error(
+      `executionCondition must be exactly ${CONDITION_LENGTH} bytes, got ${condition.length}`
+    );
+  }
+}
+function fulfillmentMatchesCondition(fulfillment, condition) {
+  if (fulfillment === void 0 || fulfillment.length !== CONDITION_LENGTH) {
+    return false;
+  }
+  const digest = sha256(fulfillment);
+  for (let i = 0; i < CONDITION_LENGTH; i++) {
+    if (digest[i] !== condition[i]) return false;
+  }
+  return true;
+}
+
+// src/adapters/ilp-send.ts
+function resolveExpiresAt(expiresAt, timeoutMs) {
+  if (expiresAt === void 0) return new Date(Date.now() + timeoutMs);
+  return expiresAt instanceof Date ? new Date(expiresAt.getTime()) : new Date(expiresAt);
+}
+var FULFILLMENT_MISMATCH_CODE = "F99";
+var FULFILLMENT_MISMATCH_MESSAGE = "FULFILL fulfillment does not match execution condition (sha256(fulfillment) != executionCondition) \u2014 packet counted failed";
+function mapIlpResponse(packet, sentCondition) {
+  if (packet.type === ILPPacketType.FULFILL) {
+    const dataField = packet.data.length > 0 ? { data: toBase64(packet.data) } : {};
+    if (sentCondition === void 0 || isZeroCondition(sentCondition)) {
+      return { accepted: true, ...dataField };
+    }
+    if (!fulfillmentMatchesCondition(packet.fulfillment, sentCondition)) {
+      return {
+        accepted: false,
+        code: FULFILLMENT_MISMATCH_CODE,
+        message: FULFILLMENT_MISMATCH_MESSAGE,
+        ...dataField
+      };
+    }
+    return {
+      accepted: true,
+      fulfillment: toBase64(packet.fulfillment),
+      ...dataField
+    };
+  }
+  return {
+    accepted: false,
+    code: packet.code,
+    message: packet.message,
+    ...packet.data.length > 0 ? { data: toBase64(packet.data) } : {}
+  };
+}
+
 // src/adapters/BtpRuntimeClient.ts
 function isConnectionError(error) {
   const msg = error.message.toLowerCase();
@@ -1324,6 +1398,12 @@ var BtpRuntimeClient = class {
   /**
    * Sends an ILP packet via BTP with auto-reconnect on connection errors.
    * Satisfies IlpClient interface.
+   *
+   * `params` may carry a sender-chosen `executionCondition` and an explicit
+   * `expiresAt` (toon-client#350); omitting both is the legacy zero-condition
+   * path, unchanged. With a non-zero condition the FULFILL preimage is
+   * verified (`sha256(fulfillment) == condition`) and a mismatch is surfaced
+   * as a failed result — see `mapIlpResponse`.
    */
   async sendIlpPacket(params) {
     return withRetry(() => this._sendIlpPacketOnce(params), {
@@ -1339,6 +1419,9 @@ var BtpRuntimeClient = class {
   /**
    * Sends a balance proof claim via BTP protocol data, then sends an ILP packet.
    * Auto-reconnects on connection errors.
+   *
+   * Sender-chosen `executionCondition` / explicit `expiresAt` semantics are
+   * identical to {@link sendIlpPacket}.
    */
   async sendIlpPacketWithClaim(params, claim) {
     return withRetry(() => this._sendIlpPacketWithClaimOnce(params, claim), {
@@ -1381,6 +1464,30 @@ var BtpRuntimeClient = class {
       encodeUtf8(JSON.stringify(claim))
     );
   }
+  /**
+   * Build the ILP PREPARE for a send, applying the sender-chosen condition /
+   * explicit expiry when provided (toon-client#350) and validating that a
+   * non-zero condition is exactly 32 bytes (the OER serializer would
+   * otherwise silently zero-fill it, downgrading the packet to the legacy
+   * unverified class).
+   */
+  buildPrepare(params) {
+    const condition = params.executionCondition;
+    if (condition !== void 0 && !isZeroCondition(condition)) {
+      assertValidCondition(condition);
+    }
+    return {
+      prepare: {
+        type: 12,
+        amount: BigInt(params.amount),
+        destination: params.destination,
+        executionCondition: condition ?? new Uint8Array(32),
+        expiresAt: resolveExpiresAt(params.expiresAt, params.timeout ?? 3e4),
+        data: fromBase64(params.data)
+      },
+      condition
+    };
+  }
   /**
    * Single-attempt ILP packet send. Reconnects if not connected.
    */
@@ -1388,26 +1495,9 @@ var BtpRuntimeClient = class {
     if (!this._isConnected) {
       await this.reconnect();
     }
-    const response = await this.btpClient.sendPacket({
-      type: 12,
-      amount: BigInt(params.amount),
-      destination: params.destination,
-      executionCondition: new Uint8Array(32),
-      expiresAt: new Date(Date.now() + (params.timeout ?? 3e4)),
-      data: fromBase64(params.data)
-    });
-    if (response.type === ILPPacketType.FULFILL) {
-      return {
-        accepted: true,
-        data: response.data.length > 0 ? toBase64(response.data) : void 0
-      };
-    }
-    return {
-      accepted: false,
-      code: response.code,
-      message: response.message,
-      data: response.data.length > 0 ? toBase64(response.data) : void 0
-    };
+    const { prepare, condition } = this.buildPrepare(params);
+    const response = await this.btpClient.sendPacket(prepare);
+    return mapIlpResponse(response, condition);
   }
   /**
    * Single-attempt claim + ILP packet send. Reconnects if not connected.
@@ -1426,29 +1516,9 @@ var BtpRuntimeClient = class {
         data: encodeUtf8(JSON.stringify(claim))
       }
     ];
-    const response = await this.btpClient.sendPacket(
-      {
-        type: 12,
-        amount: BigInt(params.amount),
-        destination: params.destination,
-        executionCondition: new Uint8Array(32),
-        expiresAt: new Date(Date.now() + (params.timeout ?? 3e4)),
-        data: fromBase64(params.data)
-      },
-      protocolData
-    );
-    if (response.type === ILPPacketType.FULFILL) {
-      return {
-        accepted: true,
-        data: response.data.length > 0 ? toBase64(response.data) : void 0
-      };
-    }
-    return {
-      accepted: false,
-      code: response.code,
-      message: response.message,
-      data: response.data.length > 0 ? toBase64(response.data) : void 0
-    };
+    const { prepare, condition } = this.buildPrepare(params);
+    const response = await this.btpClient.sendPacket(prepare, protocolData);
+    return mapIlpResponse(response, condition);
   }
 };
 
@@ -1480,6 +1550,12 @@ var HttpIlpClient = class {
    * Send an ILP PREPARE via `POST /ilp` WITHOUT a claim. The connector accepts
    * this only on free/zero-amount routes; paid writes must use
    * {@link sendIlpPacketWithClaim}. Satisfies the IlpClient interface.
+   *
+   * `params` may carry a sender-chosen `executionCondition` and an explicit
+   * `expiresAt` (toon-client#350); omitting both is the legacy zero-condition
+   * path, unchanged. With a non-zero condition the FULFILL preimage is
+   * verified (`sha256(fulfillment) == condition`) and a mismatch is surfaced
+   * as a failed result — see {@link mapIlpResponse}.
    */
   async sendIlpPacket(params) {
     return withRetry(() => this.postPrepare(params), {
@@ -1494,6 +1570,9 @@ var HttpIlpClient = class {
    * as the `ILP-Payment-Channel-Claim` header. `claim` is the SAME JSON object
    * the BTP path attaches as the `payment-channel-claim` protocolData entry —
    * we base64(JSON.stringify(claim)) it, byte-for-byte identical to BTP.
+   *
+   * Sender-chosen `executionCondition` / explicit `expiresAt` semantics are
+   * identical to {@link sendIlpPacket}.
    */
   async sendIlpPacketWithClaim(params, claim) {
     return withRetry(() => this.postPrepare(params, claim), {
@@ -1546,12 +1625,16 @@ var HttpIlpClient = class {
    */
   async postPrepare(params, claim) {
     const requestTimeout = params.timeout ?? this.timeout;
+    const condition = params.executionCondition;
+    if (condition !== void 0 && !isZeroCondition(condition)) {
+      assertValidCondition(condition);
+    }
     const prepare = serializeIlpPrepare({
       type: ILPPacketType.PREPARE,
       amount: BigInt(params.amount),
       destination: params.destination,
-      executionCondition: new Uint8Array(32),
-      expiresAt: new Date(Date.now() + requestTimeout),
+      executionCondition: condition ?? new Uint8Array(32),
+      expiresAt: resolveExpiresAt(params.expiresAt, requestTimeout),
       data: fromBase64(params.data)
     });
     const headers = {
@@ -1574,7 +1657,7 @@ var HttpIlpClient = class {
         signal: controller.signal
       });
       clearTimeout(timeoutId);
-      return await this.mapResponse(response);
+      return await this.mapResponse(response, condition);
     } catch (error) {
       clearTimeout(timeoutId);
       throw this.mapTransportError(error, requestTimeout);
@@ -1584,26 +1667,18 @@ var HttpIlpClient = class {
    * Map a `200 OK` body (OER FULFILL/REJECT) to an IlpSendResult; map a non-2xx
    * to a transport error. Per the wire contract, ILP-level rejects arrive as a
    * 200 + REJECT body — only HTTP non-2xx means a transport-layer failure.
+   *
+   * When `sentCondition` is non-zero the FULFILL preimage is verified against
+   * it; a mismatch yields `accepted: false` (shared `mapIlpResponse` logic,
+   * identical to the BTP path).
    */
-  async mapResponse(response) {
+  async mapResponse(response, sentCondition) {
     if (response.ok) {
       const buf = new Uint8Array(await response.arrayBuffer());
       if (buf.length === 0) {
         throw new ConnectorError("Empty 200 body from /ilp (expected OER ILP response)");
       }
-      const ilp = deserializeIlpPacket(buf);
-      if (ilp.type === ILPPacketType.FULFILL) {
-        return {
-          accepted: true,
-          data: ilp.data.length > 0 ? toBase64(ilp.data) : void 0
-        };
-      }
-      return {
-        accepted: false,
-        code: ilp.code,
-        message: ilp.message,
-        data: ilp.data.length > 0 ? toBase64(ilp.data) : void 0
-      };
+      return mapIlpResponse(deserializeIlpPacket(buf), sentCondition);
     }
     const body = await response.text().catch(() => "");
     const detail = body ? `: ${body}` : "";
@@ -1663,17 +1738,17 @@ function readDiscoveredIlpPeer(peer) {
 }
 function selectIlpTransport(peer, options = {}) {
   const needsDuplex = options.needsDuplex ?? false;
-  const http3 = peer.httpEndpoint?.trim() || void 0;
+  const http4 = peer.httpEndpoint?.trim() || void 0;
   const btp = peer.btpEndpoint?.trim() || void 0;
   const canUpgrade = peer.supportsUpgrade === true;
   if (needsDuplex) {
     if (btp) return { kind: "btp", btpEndpoint: btp };
-    if (http3 && canUpgrade) return { kind: "http-upgradable", httpEndpoint: http3 };
+    if (http4 && canUpgrade) return { kind: "http-upgradable", httpEndpoint: http4 };
     throw new Error(
       "Duplex transport required but peer exposes neither a btpEndpoint nor an upgradable httpEndpoint"
     );
   }
-  if (http3) return { kind: "http", httpEndpoint: http3, canUpgrade };
+  if (http4) return { kind: "http", httpEndpoint: http4, canUpgrade };
   if (btp) return { kind: "btp", btpEndpoint: btp };
   throw new Error("Peer exposes neither an httpEndpoint nor a btpEndpoint");
 }
@@ -1692,7 +1767,7 @@ import { base58Encode as base58Encode2 } from "@toon-protocol/core";
 
 // src/channel/solana-payment-channel.ts
 import { ed25519 } from "@noble/curves/ed25519.js";
-import { sha256 } from "@noble/hashes/sha2.js";
+import { sha256 as sha2562 } from "@noble/hashes/sha2.js";
 import { base58Encode, base58Decode } from "@toon-protocol/core";
 var TOKEN_PROGRAM_ID = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
 var SYSTEM_PROGRAM_ID = "11111111111111111111111111111111";
@@ -1781,7 +1856,7 @@ function findProgramAddress(seeds, programId) {
     input.set(programId, offset);
     offset += programId.length;
     input.set(PDA_MARKER, offset);
-    const hash = sha256(input);
+    const hash = sha2562(input);
     if (!isOnCurve(hash)) return { pda: hash, bump };
   }
   throw new Error("Could not find a viable PDA bump seed");
@@ -1894,13 +1969,13 @@ async function buildAndSendTransaction(rpcUrl, feePayer, instructions, additiona
     isWritable: true
   });
   for (const ix of instructions) {
-    for (const key of ix.keys) {
-      const existing = accountMap.get(key.pubkey);
+    for (const key2 of ix.keys) {
+      const existing = accountMap.get(key2.pubkey);
       if (existing) {
-        existing.isSigner = existing.isSigner || key.isSigner;
-        existing.isWritable = existing.isWritable || key.isWritable;
+        existing.isSigner = existing.isSigner || key2.isSigner;
+        existing.isWritable = existing.isWritable || key2.isWritable;
       } else {
-        accountMap.set(key.pubkey, { ...key });
+        accountMap.set(key2.pubkey, { ...key2 });
       }
     }
     if (!accountMap.has(ix.programId)) {
@@ -3234,7 +3309,7 @@ var SolanaSigner = class {
 
 // src/signing/mina-signer.ts
 import { hexToMinaBase58PrivateKey as hexToMinaBase58PrivateKey3 } from "@toon-protocol/core";
-import { sha256 as sha2562 } from "@noble/hashes/sha2.js";
+import { sha256 as sha2563 } from "@noble/hashes/sha2.js";
 import { bytesToHex } from "@noble/hashes/utils.js";
 
 // src/channel/mina-payment-channel.ts
@@ -3365,7 +3440,7 @@ var DEFAULT_MINA_TOKEN_ID = "MINA";
 var MINA_CLAIM_NETWORK = "devnet";
 function deriveMinaSalt(zkAppAddress, nonce) {
   const digestHex = bytesToHex(
-    sha2562(new TextEncoder().encode(`mina-pc-salt:${zkAppAddress}:${nonce}`))
+    sha2563(new TextEncoder().encode(`mina-pc-salt:${zkAppAddress}:${nonce}`))
   );
   const salt = BigInt("0x" + digestHex.slice(0, 60));
   return salt === 0n ? 1n : salt;
@@ -4196,8 +4271,8 @@ async function requestBlobStorage(client, secretKey, params) {
   };
 }
 function extractArweaveTxId(base64Data) {
-  const http3 = parseFulfillHttp(base64Data);
-  if (!http3.isHttp) {
+  const http4 = parseFulfillHttp(base64Data);
+  if (!http4.isHttp) {
     const legacy = decodeUtf8(fromBase64(base64Data));
     if (!ARWEAVE_TX_ID_REGEX.test(legacy)) {
       throw new Error(
@@ -4206,18 +4281,18 @@ function extractArweaveTxId(base64Data) {
     }
     return legacy;
   }
-  if (http3.status < 200 || http3.status >= 300) {
-    const detail = http3.body ? ` - ${http3.body}` : "";
+  if (http4.status < 200 || http4.status >= 300) {
+    const detail = http4.body ? ` - ${http4.body}` : "";
     throw new Error(
-      `Blob upload failed: DVM returned HTTP ${http3.status} ${http3.statusText}`.trimEnd() + detail
+      `Blob upload failed: DVM returned HTTP ${http4.status} ${http4.statusText}`.trimEnd() + detail
     );
   }
   let parsed;
   try {
-    parsed = JSON.parse(http3.body);
+    parsed = JSON.parse(http4.body);
   } catch {
     throw new Error(
-      `Blob upload response body was not valid JSON: "${http3.body}"`
+      `Blob upload response body was not valid JSON: "${http4.body}"`
     );
   }
   const body = parsed;
@@ -4235,7 +4310,7 @@ function extractArweaveTxId(base64Data) {
     }
   }
   throw new Error(
-    `Blob upload response did not contain a valid Arweave tx ID: "${http3.body}"`
+    `Blob upload response did not contain a valid Arweave tx ID: "${http4.body}"`
   );
 }
 
@@ -4490,6 +4565,172 @@ function parseHttpResponse(bytes) {
   );
 }
 
+// src/swap/settle-received-claims.ts
+import {
+  buildSettlementTx,
+  SettlementTxError
+} from "@toon-protocol/sdk";
+import {
+  createPublicClient as createPublicClient3,
+  defineChain as defineChain3,
+  fromRlp,
+  http as http3
+} from "viem";
+function entryToAccumulatedClaim(entry) {
+  return {
+    packetIndex: 0,
+    sourceAmount: 0n,
+    targetAmount: entry.cumulativeAmount,
+    claimBytes: entry.claimBytes,
+    swapEphemeralPubkey: "",
+    ...entry.claimId !== void 0 ? { claimId: entry.claimId } : {},
+    pair: entry.pair,
+    receivedAt: entry.receivedAt,
+    channelId: entry.channelId,
+    nonce: entry.nonce.toString(),
+    cumulativeAmount: entry.cumulativeAmount.toString(),
+    recipient: entry.recipient,
+    swapSignerAddress: entry.swapSignerAddress
+  };
+}
+function parseEvmChainId2(chain) {
+  const parts = chain.split(":");
+  const raw = parts.length >= 3 ? parts[2] : parts[1];
+  const chainId = Number.parseInt(raw ?? "", 10);
+  return Number.isInteger(chainId) && chainId > 0 ? chainId : void 0;
+}
+function buildSwapSettlements(params) {
+  return params.entries.map((entry) => {
+    const base = { chain: entry.chain, channelId: entry.channelId };
+    const signer = { address: entry.swapSignerAddress };
+    const contract = params.tokenNetworks?.[entry.chain];
+    if (entry.chain.startsWith("evm")) {
+      const chainId = parseEvmChainId2(entry.chain);
+      if (!contract || chainId === void 0) {
+        return {
+          ...base,
+          error: {
+            code: "MISSING_CHAIN_CONFIG",
+            message: `EVM settlement for ${entry.chain} needs tokenNetworks["${entry.chain}"] (TokenNetwork contract) and a numeric chain id in the chain key.`
+          }
+        };
+      }
+      signer.contractAddress = contract;
+      signer.chainId = chainId;
+    } else if (entry.chain.startsWith("solana")) {
+      if (!contract) {
+        return {
+          ...base,
+          error: {
+            code: "MISSING_CHAIN_CONFIG",
+            message: `Solana settlement for ${entry.chain} needs tokenNetworks["${entry.chain}"] (programId).`
+          }
+        };
+      }
+      signer.programId = contract;
+    }
+    try {
+      const result = buildSettlementTx({
+        claims: [entryToAccumulatedClaim(entry)],
+        signers: { [entry.chain]: signer },
+        recipients: { [entry.chain]: entry.recipient },
+        ...params.minaSignerClient ? { minaSignerClient: params.minaSignerClient } : {}
+      });
+      const firstRejected = result.rejected[0];
+      if (firstRejected) {
+        return {
+          ...base,
+          error: {
+            code: firstRejected.reason,
+            message: firstRejected.details ?? `stored claim for ${entry.chain}/${entry.channelId} failed settlement re-verification`
+          }
+        };
+      }
+      const bundle = result.bundles[0];
+      if (!bundle) {
+        return {
+          ...base,
+          error: {
+            code: "NO_BUNDLE",
+            message: `buildSettlementTx produced no bundle for ${entry.chain}/${entry.channelId}`
+          }
+        };
+      }
+      return { ...base, bundle };
+    } catch (err) {
+      const code = err instanceof SettlementTxError ? err.code : "BUILD_FAILED";
+      return {
+        ...base,
+        error: {
+          code,
+          message: err instanceof Error ? err.message : String(err)
+        }
+      };
+    }
+  });
+}
+function decodeEvmSettlementTx(bundle) {
+  const fields = fromRlp(bundle.unsignedTxBytes, "hex");
+  if (!Array.isArray(fields) || fields.length !== 9) {
+    throw new Error(
+      `settlement bundle RLP is not a 9-field unsigned EVM tx (got ${Array.isArray(fields) ? fields.length : typeof fields})`
+    );
+  }
+  const to = fields[3];
+  const data = fields[5];
+  const chainIdHex = fields[6];
+  const chainId = Number.parseInt(chainIdHex === "0x" ? "0x0" : chainIdHex, 16);
+  if (typeof to !== "string" || to.length !== 42) {
+    throw new Error(`settlement tx "to" is not a 20-byte address: ${String(to)}`);
+  }
+  return { to, data: data === "0x" ? "0x" : data, chainId };
+}
+async function submitEvmSettlement(bundle, params) {
+  if (bundle.chainKind !== "evm") {
+    throw new Error(
+      `submitEvmSettlement only submits evm bundles (got ${bundle.chainKind} for ${bundle.chain})`
+    );
+  }
+  const { to, data, chainId } = decodeEvmSettlementTx(bundle);
+  const chain = defineChain3({
+    id: chainId,
+    name: bundle.chain,
+    nativeCurrency: { name: "ETH", symbol: "ETH", decimals: 18 },
+    rpcUrls: { default: { http: [params.rpcUrl] } }
+  });
+  const publicClient = createPublicClient3({ chain, transport: http3(params.rpcUrl) });
+  const [nonce, gasPrice, gas] = await Promise.all([
+    publicClient.getTransactionCount({
+      address: params.account.address,
+      blockTag: "pending"
+    }),
+    publicClient.getGasPrice(),
+    publicClient.estimateGas({ account: params.account.address, to, data })
+  ]);
+  const signed = await params.account.signTransaction({
+    type: "legacy",
+    chainId,
+    nonce,
+    gasPrice,
+    gas,
+    to,
+    value: 0n,
+    data
+  });
+  const txHash = await publicClient.sendRawTransaction({
+    serializedTransaction: signed
+  });
+  try {
+    const receipt = await publicClient.waitForTransactionReceipt({
+      hash: txHash,
+      timeout: params.timeoutMs ?? 6e4
+    });
+    return { txHash, status: receipt.status };
+  } catch {
+    return { txHash };
+  }
+}
+
 // src/ToonClient.ts
 var ToonClient = class {
   config;
@@ -4897,6 +5138,14 @@ var ToonClient = class {
    *       matching `destination`,
    *   (c) neither -> throw MISSING_CLAIM.
    *
+   * A caller may supply a sender-chosen 32-byte `executionCondition`
+   * (`C = sha256(P)`, one fresh preimage per packet — toon-client#350,
+   * rolling-swap spec §3 R1/R2) and an explicit `expiresAt` (R7). Both are
+   * set on the wire by either transport (HTTP `POST /ilp` and BTP), and on
+   * FULFILL the transport verifies `sha256(fulfillment) == condition` —
+   * a mismatch comes back as `accepted: false` (code F99), never a silent
+   * accept. Omitting them keeps today's zero-condition legacy packet.
+   *
    * @throws {ToonClientError} INVALID_STATE / NO_ILP_TRANSPORT / MISSING_CLAIM
    */
   async sendSwapPacket(params) {
@@ -4917,7 +5166,9 @@ var ToonClient = class {
         destination: params.destination,
         amount: String(params.amount),
         data: toBase64(params.toonData),
-        timeout: params.timeout ?? 3e4
+        timeout: params.timeout ?? 3e4,
+        ...params.executionCondition ? { executionCondition: params.executionCondition } : {},
+        ...params.expiresAt ? { expiresAt: params.expiresAt } : {}
       },
       claimMessage
     );
@@ -5196,6 +5447,38 @@ var ToonClient = class {
     this.channelManager.setChannelSettled(channelId, nowSec);
     return { channelId, ...r.txHash ? { txHash: r.txHash } : {} };
   }
+  /**
+   * Submit a receive-side swap settlement bundle on-chain (toon-client#352).
+   * The bundle comes from the sdk's `buildSettlementTx` over persisted,
+   * verified chain-B claims (`buildSwapSettlements`); this signs it with the
+   * client's EVM account (the claim recipient) and broadcasts it.
+   *
+   * Env-gated seam: EVM only, and only when `chainRpcUrls[bundle.chain]` is
+   * configured — otherwise this throws a clear config error and callers
+   * surface a built-not-submitted result. Solana submission and the Mina
+   * receive-side co-sign path are explicit follow-ups (see
+   * swap/settle-received-claims.ts module doc).
+   */
+  async settleSwapBundle(bundle) {
+    if (bundle.chainKind !== "evm") {
+      throw new Error(
+        `Swap settlement submission for ${bundle.chainKind} (${bundle.chain}) is not wired yet \u2014 EVM only today.`
+      );
+    }
+    const rpcUrl = this.config.chainRpcUrls?.[bundle.chain];
+    if (!rpcUrl) {
+      throw new Error(
+        `No RPC URL configured for chain "${bundle.chain}" \u2014 add it to chainRpcUrls to enable swap settlement submission.`
+      );
+    }
+    if (!this.evmSigner) {
+      throw new Error("EVM signer not configured (no evmPrivateKey/mnemonic).");
+    }
+    return submitEvmSettlement(bundle, {
+      rpcUrl,
+      account: this.evmSigner.account
+    });
+  }
   /** Where a tracked channel sits in the withdraw journey. */
   getChannelCloseState(channelId) {
     if (!this.channelManager) throw new Error("ChannelManager not initialized");
@@ -5794,6 +6077,238 @@ var HttpConnectorAdmin = class {
   }
 };
 
+// src/channel/ReceivedClaimStore.ts
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, existsSync as existsSync2, mkdirSync } from "fs";
+import { dirname } from "path";
+function key(chain, channelId) {
+  return `${chain}|${channelId}`;
+}
+var JsonFileReceivedClaimStore = class {
+  filePath;
+  constructor(filePath) {
+    this.filePath = filePath;
+  }
+  save(entry) {
+    const data = this.readFile();
+    data[key(entry.chain, entry.channelId)] = {
+      chain: entry.chain,
+      channelId: entry.channelId,
+      nonce: entry.nonce.toString(),
+      cumulativeAmount: entry.cumulativeAmount.toString(),
+      recipient: entry.recipient,
+      swapSignerAddress: entry.swapSignerAddress,
+      claimBytes: Buffer.from(entry.claimBytes).toString("base64"),
+      ...entry.claimId !== void 0 ? { claimId: entry.claimId } : {},
+      pair: entry.pair,
+      receivedAt: entry.receivedAt,
+      updatedAt: entry.updatedAt,
+      ...entry.settledAt !== void 0 ? { settledAt: entry.settledAt } : {},
+      ...entry.settledNonce !== void 0 ? { settledNonce: entry.settledNonce.toString() } : {},
+      ...entry.settleTxHash !== void 0 ? { settleTxHash: entry.settleTxHash } : {}
+    };
+    this.writeFile(data);
+  }
+  load(chain, channelId) {
+    const entry = this.readFile()[key(chain, channelId)];
+    return entry ? fromJson(entry) : void 0;
+  }
+  list() {
+    return Object.values(this.readFile()).map(fromJson);
+  }
+  delete(chain, channelId) {
+    const data = this.readFile();
+    const { [key(chain, channelId)]: _, ...rest } = data;
+    this.writeFile(rest);
+  }
+  readFile() {
+    if (!existsSync2(this.filePath)) {
+      return {};
+    }
+    const raw = readFileSync2(this.filePath, "utf-8");
+    return JSON.parse(raw);
+  }
+  writeFile(data) {
+    mkdirSync(dirname(this.filePath), { recursive: true });
+    writeFileSync2(this.filePath, JSON.stringify(data, null, 2), "utf-8");
+  }
+};
+var InMemoryReceivedClaimStore = class {
+  entries = /* @__PURE__ */ new Map();
+  save(entry) {
+    this.entries.set(key(entry.chain, entry.channelId), { ...entry });
+  }
+  load(chain, channelId) {
+    const entry = this.entries.get(key(chain, channelId));
+    return entry ? { ...entry } : void 0;
+  }
+  list() {
+    return [...this.entries.values()].map((e) => ({ ...e }));
+  }
+  delete(chain, channelId) {
+    this.entries.delete(key(chain, channelId));
+  }
+};
+function fromJson(entry) {
+  return {
+    chain: entry.chain,
+    channelId: entry.channelId,
+    nonce: BigInt(entry.nonce),
+    cumulativeAmount: BigInt(entry.cumulativeAmount),
+    recipient: entry.recipient,
+    swapSignerAddress: entry.swapSignerAddress,
+    claimBytes: new Uint8Array(Buffer.from(entry.claimBytes, "base64")),
+    ...entry.claimId !== void 0 ? { claimId: entry.claimId } : {},
+    pair: entry.pair,
+    receivedAt: entry.receivedAt,
+    updatedAt: entry.updatedAt,
+    ...entry.settledAt !== void 0 ? { settledAt: entry.settledAt } : {},
+    ...entry.settledNonce !== void 0 ? { settledNonce: BigInt(entry.settledNonce) } : {},
+    ...entry.settleTxHash !== void 0 ? { settleTxHash: entry.settleTxHash } : {}
+  };
+}
+
+// src/swap/received-claims.ts
+import {
+  verifyAccumulatedClaim
+} from "@toon-protocol/sdk";
+function hasSettlementMetadata(claim) {
+  return claim.channelId !== void 0 && claim.nonce !== void 0 && claim.cumulativeAmount !== void 0 && claim.recipient !== void 0 && claim.swapSignerAddress !== void 0;
+}
+function sameAddress(chain, a, b) {
+  return chain.startsWith("evm") ? a.toLowerCase() === b.toLowerCase() : a === b;
+}
+function signatureRejectionCode(reason) {
+  if (reason.startsWith("SIGNER_MISMATCH")) return "SIGNER_MISMATCH";
+  if (reason.startsWith("MINA_VERIFICATION_UNSUPPORTED"))
+    return "MINA_VERIFICATION_UNSUPPORTED";
+  if (reason.startsWith("UNSUPPORTED_CHAIN")) return "UNSUPPORTED_CHAIN";
+  return "SIGNATURE_INVALID";
+}
+function ingestReceivedClaims(params) {
+  const now = params.now ?? Date.now;
+  const verified = [];
+  const rejected = [];
+  const legacy = [];
+  let valueReceived = 0n;
+  const watermarks = /* @__PURE__ */ new Map();
+  const reject = (claim, code, message) => {
+    rejected.push({ claim, code, message });
+  };
+  for (const claim of params.claims) {
+    if (!hasSettlementMetadata(claim)) {
+      legacy.push(claim);
+      continue;
+    }
+    const chain = claim.pair.to.chain;
+    if (chain !== params.expectedChain) {
+      reject(
+        claim,
+        "CHAIN_MISMATCH",
+        `claim settles on "${chain}", session expected "${params.expectedChain}"`
+      );
+      continue;
+    }
+    if (!sameAddress(chain, claim.recipient, params.chainRecipient)) {
+      reject(
+        claim,
+        "RECIPIENT_MISMATCH",
+        `claim recipient "${claim.recipient}" is not the session chainRecipient "${params.chainRecipient}"`
+      );
+      continue;
+    }
+    if (params.expectedSignerAddress !== void 0 && !sameAddress(chain, claim.swapSignerAddress, params.expectedSignerAddress)) {
+      reject(
+        claim,
+        "SWAP_SIGNER_MISMATCH",
+        `claim swapSignerAddress "${claim.swapSignerAddress}" does not match the maker's advertised signer "${params.expectedSignerAddress}"`
+      );
+      continue;
+    }
+    const expectedSigner = params.expectedSignerAddress ?? claim.swapSignerAddress;
+    const sig = verifyAccumulatedClaim(
+      claim,
+      { address: expectedSigner },
+      params.minaSignerClient
+    );
+    if (!sig.valid) {
+      reject(claim, signatureRejectionCode(sig.reason), sig.reason);
+      continue;
+    }
+    let nonce;
+    let cumulativeAmount;
+    try {
+      nonce = BigInt(claim.nonce);
+      cumulativeAmount = BigInt(claim.cumulativeAmount);
+    } catch {
+      reject(
+        claim,
+        "MALFORMED_METADATA",
+        `nonce "${claim.nonce}" / cumulativeAmount "${claim.cumulativeAmount}" are not decimal integers`
+      );
+      continue;
+    }
+    const wmKey = `${chain}|${claim.channelId}`;
+    const watermark = watermarks.get(wmKey) ?? params.store.load(chain, claim.channelId);
+    if (watermark) {
+      if (!sameAddress(chain, watermark.swapSignerAddress, expectedSigner)) {
+        reject(
+          claim,
+          "SWAP_SIGNER_MISMATCH",
+          `channel ${claim.channelId} watermark was signed by "${watermark.swapSignerAddress}"; a claim signed by "${expectedSigner}" may not rotate it`
+        );
+        continue;
+      }
+      if (nonce <= watermark.nonce) {
+        reject(
+          claim,
+          "NON_MONOTONIC_NONCE",
+          `nonce ${nonce} does not advance the persisted watermark nonce ${watermark.nonce} for channel ${claim.channelId}`
+        );
+        continue;
+      }
+      if (cumulativeAmount <= watermark.cumulativeAmount) {
+        reject(
+          claim,
+          "NON_MONOTONIC_CUMULATIVE",
+          `cumulativeAmount ${cumulativeAmount} does not advance the persisted watermark ${watermark.cumulativeAmount} for channel ${claim.channelId}`
+        );
+        continue;
+      }
+    }
+    const advance = cumulativeAmount - (watermark?.cumulativeAmount ?? 0n);
+    if (advance < claim.targetAmount) {
+      reject(
+        claim,
+        "CUMULATIVE_SHORTFALL",
+        `cumulative advance ${advance} is less than the packet's targetAmount ${claim.targetAmount} for channel ${claim.channelId}`
+      );
+      continue;
+    }
+    const entry = {
+      chain,
+      channelId: claim.channelId,
+      nonce,
+      cumulativeAmount,
+      recipient: claim.recipient,
+      swapSignerAddress: expectedSigner,
+      claimBytes: claim.claimBytes,
+      ...claim.claimId !== void 0 ? { claimId: claim.claimId } : {},
+      pair: claim.pair,
+      receivedAt: claim.receivedAt,
+      updatedAt: now(),
+      // Settlement bookkeeping survives watermark advances.
+      ...watermark?.settledAt !== void 0 ? { settledAt: watermark.settledAt } : {},
+      ...watermark?.settledNonce !== void 0 ? { settledNonce: watermark.settledNonce } : {},
+      ...watermark?.settleTxHash !== void 0 ? { settleTxHash: watermark.settleTxHash } : {}
+    };
+    params.store.save(entry);
+    watermarks.set(wmKey, entry);
+    verified.push({ claim, watermarkAdvance: advance });
+    valueReceived += advance;
+  }
+  return { verified, rejected, legacy, valueReceived };
+}
+
 // src/faucet.ts
 function defaultFaucetTimeout(chain) {
   return chain === "mina" ? 12e4 : 3e4;
@@ -6771,9 +7286,9 @@ import {
   scryptSync,
   createCipheriv,
   createDecipheriv,
-  randomBytes
+  randomBytes as randomBytes2
 } from "crypto";
-import { writeFileSync as writeFileSync2, readFileSync as readFileSync2 } from "fs";
+import { writeFileSync as writeFileSync3, readFileSync as readFileSync3 } from "fs";
 var SCRYPT_N = 2 ** 17;
 var SCRYPT_R = 8;
 var SCRYPT_P = 1;
@@ -6798,16 +7313,16 @@ function encryptMnemonic2(mnemonic, password) {
   if (typeof password !== "string" || password.length === 0) {
     throw new Error("encryptMnemonic: password must be a non-empty string");
   }
-  const salt = randomBytes(SALT_LEN);
-  const iv = randomBytes(IV_LEN);
-  const key = scryptSync(password, salt, SCRYPT_KEY_LEN, {
+  const salt = randomBytes2(SALT_LEN);
+  const iv = randomBytes2(IV_LEN);
+  const key2 = scryptSync(password, salt, SCRYPT_KEY_LEN, {
     N: SCRYPT_N,
     r: SCRYPT_R,
     p: SCRYPT_P,
     maxmem: SCRYPT_MAXMEM
   });
   try {
-    const cipher = createCipheriv("aes-256-gcm", key, iv, {
+    const cipher = createCipheriv("aes-256-gcm", key2, iv, {
       authTagLength: AUTH_TAG_LEN
     });
     const ciphertext = Buffer.concat([
@@ -6823,7 +7338,7 @@ function encryptMnemonic2(mnemonic, password) {
       version: 1
     };
   } finally {
-    key.fill(0);
+    key2.fill(0);
   }
 }
 function decryptMnemonic2(encrypted, password) {
@@ -6838,14 +7353,14 @@ function decryptMnemonic2(encrypted, password) {
   const iv = Buffer.from(encrypted.iv, "base64");
   const ciphertext = Buffer.from(encrypted.ciphertext, "base64");
   const tag = Buffer.from(encrypted.tag, "base64");
-  const key = scryptSync(password, salt, SCRYPT_KEY_LEN, {
+  const key2 = scryptSync(password, salt, SCRYPT_KEY_LEN, {
     N: SCRYPT_N,
     r: SCRYPT_R,
     p: SCRYPT_P,
     maxmem: SCRYPT_MAXMEM
   });
   try {
-    const decipher = createDecipheriv("aes-256-gcm", key, iv, {
+    const decipher = createDecipheriv("aes-256-gcm", key2, iv, {
       authTagLength: AUTH_TAG_LEN
     });
     decipher.setAuthTag(tag);
@@ -6861,7 +7376,7 @@ function decryptMnemonic2(encrypted, password) {
       );
     }
   } finally {
-    key.fill(0);
+    key2.fill(0);
   }
 }
 function generateKeystore(path, password) {
@@ -6884,7 +7399,7 @@ function importKeystore(path, mnemonic, password) {
 }
 function loadKeystore(path, password) {
   assertNode();
-  const raw = readFileSync2(path, "utf8");
+  const raw = readFileSync3(path, "utf8");
   let parsed;
   try {
     parsed = JSON.parse(raw);
@@ -6895,17 +7410,20 @@ function loadKeystore(path, password) {
 }
 function writeKeystoreFile(path, keystore) {
   assertNode();
-  writeFileSync2(path, JSON.stringify(keystore, null, 2), {
+  writeFileSync3(path, JSON.stringify(keystore, null, 2), {
     encoding: "utf8",
     mode: 384
   });
 }
 export {
   BtpRuntimeClient,
+  CONDITION_LENGTH,
   ChannelFundingError,
   ChannelManager,
   ConnectorError,
   EvmSigner,
+  FULFILLMENT_MISMATCH_CODE,
+  FULFILLMENT_MISMATCH_MESSAGE,
   GenerativeFallbackRenderer,
   Http402Client,
   HttpConnectorAdmin,
@@ -6914,6 +7432,8 @@ export {
   ILP_CLAIM_HEADER,
   ILP_CLAIM_WRAPPED_HEADER,
   ILP_PEER_ID_HEADER,
+  InMemoryReceivedClaimStore,
+  JsonFileReceivedClaimStore,
   KeyManager,
   KindRegistry,
   MIME_A2UI,
@@ -6930,14 +7450,17 @@ export {
   ValidationError,
   applyDefaults,
   applyNetworkPresets,
+  assertValidCondition,
   buildBackupEvent,
   buildBackupFilter,
   buildConsentRequest,
   buildRendererEventTemplate,
   buildSettlementInfo,
   buildStoreWriteEnvelope,
+  buildSwapSettlements,
   buildUiCoordinate,
   classifyIntent,
+  decodeEvmSettlementTx,
   decryptMnemonic2 as decryptMnemonic,
   defaultFaucetTimeout,
   deriveFromNsec,
@@ -6945,8 +7468,10 @@ export {
   deriveNostrKeyFromMnemonic,
   deterministicGenerator,
   encryptMnemonic2 as encryptMnemonic,
+  entryToAccumulatedClaim,
   extractArweaveTxId,
   extractUiResource,
+  fulfillmentMatchesCondition,
   fundWallet,
   generateKeystore,
   generateMnemonic,
@@ -6954,13 +7479,18 @@ export {
   getNetworkStatus,
   getUiCoordinate,
   guardedRenderDispatch,
+  hasSettlementMetadata,
   httpEndpointToBtpUrl,
   importKeystore,
+  ingestReceivedClaims,
   isInsufficientGasError,
   isPrfSupported,
   isTrustDowngrade,
+  isZeroCondition,
   loadKeystore,
+  mintExecutionCondition,
   parseBackupPayload,
+  parseEvmChainId2 as parseEvmChainId,
   parseFulfillHttp,
   parseFulfillHttpBytes,
   parseHttpResponse,
@@ -6986,6 +7516,7 @@ export {
   selectIlpTransport,
   selectLatestAddressable,
   serializeHttpRequest,
+  submitEvmSettlement,
   validateConfig,
   validateMnemonic,
   verifyRendererTrust,