@toon-protocol/client 0.17.0 → 0.19.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 };
@@ -1309,6 +1309,10 @@ function fulfillmentMatchesCondition(fulfillment, condition) {
 }
 
 // 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) {
@@ -1478,7 +1482,7 @@ var BtpRuntimeClient = class {
         amount: BigInt(params.amount),
         destination: params.destination,
         executionCondition: condition ?? new Uint8Array(32),
-        expiresAt: params.expiresAt ?? new Date(Date.now() + (params.timeout ?? 3e4)),
+        expiresAt: resolveExpiresAt(params.expiresAt, params.timeout ?? 3e4),
         data: fromBase64(params.data)
       },
       condition
@@ -1630,7 +1634,7 @@ var HttpIlpClient = class {
       amount: BigInt(params.amount),
       destination: params.destination,
       executionCondition: condition ?? new Uint8Array(32),
-      expiresAt: params.expiresAt ?? new Date(Date.now() + requestTimeout),
+      expiresAt: resolveExpiresAt(params.expiresAt, requestTimeout),
       data: fromBase64(params.data)
     });
     const headers = {
@@ -1734,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");
 }
@@ -1965,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)) {
@@ -3405,7 +3409,14 @@ async function buildMinaPaymentChannelProof(params) {
 }
 
 // src/channel/mina-deposit.ts
-var DEPOSIT_TOTAL_STATE_INDEX = 4;
+var CHANNEL_STATE_INDEX = {
+  channelHash: 0,
+  balanceCommitment: 1,
+  nonceField: 2,
+  channelState: 3,
+  depositTotal: 4
+};
+var DEPOSIT_TOTAL_STATE_INDEX = CHANNEL_STATE_INDEX.depositTotal;
 async function readMinaDepositTotal(graphqlUrl, zkAppAddress, fetchImpl = fetch) {
   const query = "query($pk:String!){account(publicKey:$pk){zkappState}}";
   const res = await fetchImpl(graphqlUrl, {
@@ -3430,6 +3441,42 @@ async function readMinaDepositTotal(graphqlUrl, zkAppAddress, fetchImpl = fetch)
   }
   return BigInt(state[DEPOSIT_TOTAL_STATE_INDEX]);
 }
+var MINA_CHANNEL_STATE = {
+  UNINITIALIZED: 0,
+  OPEN: 1,
+  CLOSING: 2,
+  SETTLED: 3
+};
+async function readMinaChannelState(graphqlUrl, zkAppAddress, fetchImpl = fetch) {
+  const query = "query($pk:String!){account(publicKey:$pk){zkappState}}";
+  const res = await fetchImpl(graphqlUrl, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ query, variables: { pk: zkAppAddress } })
+  });
+  if (!res.ok) {
+    throw new Error(`Mina GraphQL request failed: HTTP ${res.status}`);
+  }
+  const json = await res.json();
+  if (json.errors && json.errors.length > 0) {
+    throw new Error(
+      `Mina GraphQL error: ${json.errors[0]?.message ?? "unknown"}`
+    );
+  }
+  const state = json.data?.account?.zkappState;
+  if (!state || state.length <= DEPOSIT_TOTAL_STATE_INDEX) {
+    throw new Error(
+      `Mina zkApp ${zkAppAddress} has no readable zkappState (account not found or not a zkApp)`
+    );
+  }
+  return {
+    channelHash: String(state[CHANNEL_STATE_INDEX.channelHash]),
+    balanceCommitment: String(state[CHANNEL_STATE_INDEX.balanceCommitment]),
+    nonceField: BigInt(state[CHANNEL_STATE_INDEX.nonceField]),
+    channelState: Number(state[CHANNEL_STATE_INDEX.channelState]),
+    depositTotal: BigInt(state[CHANNEL_STATE_INDEX.depositTotal])
+  };
+}
 
 // src/signing/mina-signer.ts
 var DEFAULT_MINA_TOKEN_ID = "MINA";
@@ -4267,8 +4314,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(
@@ -4277,18 +4324,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;
@@ -4306,7 +4353,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}"`
   );
 }
 
@@ -4561,7 +4608,431 @@ 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/swap/mina-settlement.ts
+import { hexToMinaBase58PrivateKey as hexToMinaBase58PrivateKey4 } from "@toon-protocol/core";
+var MinaSettlementError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(`${code}: ${message}`);
+    this.name = "MinaSettlementError";
+    this.code = code;
+  }
+};
+function parseProofSignature(proofJson) {
+  const parsed = JSON.parse(proofJson);
+  const r = parsed.signature?.r;
+  const s = parsed.signature?.s;
+  if (typeof r !== "string" || typeof s !== "string") {
+    throw new Error("recipient co-signature proof did not carry string r/s");
+  }
+  return { r, s };
+}
+async function buildMinaCoSignedClaim(inputs) {
+  const channelNonce = inputs.channelNonce ?? 0n;
+  const salt = inputs.saltOverride ?? deriveMinaSalt(inputs.channelId, Number(inputs.nonce));
+  if (inputs.cumulativeAmount > inputs.depositTotal) {
+    throw new MinaSettlementError(
+      "CUMULATIVE_EXCEEDS_DEPOSIT",
+      `claim cumulativeAmount (${inputs.cumulativeAmount}) exceeds the channel depositTotal (${inputs.depositTotal}) \u2014 cannot conserve balances`
+    );
+  }
+  const { Poseidon, PublicKey } = await loadMinaPaymentChannelBindings();
+  const hashRecipientFirst = minaParticipantChannelHashField(
+    Poseidon,
+    PublicKey,
+    inputs.recipient,
+    inputs.swapSignerAddress,
+    channelNonce
+  ).toString();
+  const hashMakerFirst = minaParticipantChannelHashField(
+    Poseidon,
+    PublicKey,
+    inputs.swapSignerAddress,
+    inputs.recipient,
+    channelNonce
+  ).toString();
+  let participantA;
+  let participantB;
+  let recipientRole;
+  if (hashRecipientFirst === inputs.onChainChannelHash) {
+    participantA = inputs.recipient;
+    participantB = inputs.swapSignerAddress;
+    recipientRole = "A";
+  } else if (hashMakerFirst === inputs.onChainChannelHash) {
+    participantA = inputs.swapSignerAddress;
+    participantB = inputs.recipient;
+    recipientRole = "B";
+  } else {
+    throw new MinaSettlementError(
+      "CHANNEL_HASH_MISMATCH",
+      `neither ordering of recipient ${inputs.recipient} / maker ${inputs.swapSignerAddress} reproduces the on-chain channelHash ${inputs.onChainChannelHash} (channelNonce ${channelNonce})`
+    );
+  }
+  const recipientBalance = inputs.cumulativeAmount;
+  const makerBalance = inputs.depositTotal - inputs.cumulativeAmount;
+  const balanceA = recipientRole === "A" ? recipientBalance : makerBalance;
+  const balanceB = inputs.depositTotal - balanceA;
+  const balanceCommitment = minaBalanceCommitment(
+    Poseidon,
+    balanceA,
+    balanceB,
+    salt
+  ).toString();
+  const recipientPrivateKeyBase58 = hexToMinaBase58PrivateKey4(
+    inputs.recipientPrivateKey
+  );
+  const built = await buildMinaPaymentChannelProof({
+    zkAppAddress: inputs.channelId,
+    minaPrivateKeyBase58: recipientPrivateKeyBase58,
+    signerPublicKey: inputs.recipient,
+    balanceA,
+    balanceB,
+    salt,
+    nonce: inputs.nonce,
+    participantA,
+    participantB,
+    channelNonce,
+    proofEncoding: "json"
+  });
+  if (built.balanceCommitment !== balanceCommitment) {
+    throw new Error(
+      `co-sign commitment drift: builder ${built.balanceCommitment} != ${balanceCommitment}`
+    );
+  }
+  const recipientSignature = parseProofSignature(built.proof);
+  const signatureA = recipientRole === "A" ? recipientSignature : inputs.makerSignature;
+  const signatureB = recipientRole === "B" ? recipientSignature : inputs.makerSignature;
+  return {
+    channelId: inputs.channelId,
+    balanceA,
+    balanceB,
+    salt,
+    nonce: inputs.nonce,
+    channelNonce,
+    balanceCommitment,
+    participantA,
+    participantB,
+    recipientRole,
+    recipientSignature,
+    ...signatureA ? { signatureA } : {},
+    ...signatureB ? { signatureB } : {},
+    makerSignatureMissing: inputs.makerSignature === void 0
+  };
+}
+async function submitMinaSettlement(bundle, context) {
+  if (bundle.chainKind !== "mina") {
+    throw new MinaSettlementError(
+      "NOT_MINA_BUNDLE",
+      `submitMinaSettlement only settles mina bundles (got ${bundle.chainKind} for ${bundle.chain})`
+    );
+  }
+  if (!context.graphqlUrl) {
+    throw new MinaSettlementError(
+      "NO_GRAPHQL_CONFIGURED",
+      `no Mina graphqlUrl configured for "${bundle.chain}" \u2014 set minaChannel.graphqlUrl to enable receive-side settlement.`
+    );
+  }
+  const graphqlUrl = context.graphqlUrl;
+  const channelNonce = context.channelNonce ?? 0n;
+  const nonce = BigInt(bundle.nonce);
+  const cumulativeAmount = BigInt(bundle.cumulativeAmount);
+  const read = context.reader ?? readMinaChannelState;
+  const state = await read(graphqlUrl, bundle.channelId);
+  if (state.channelState !== MINA_CHANNEL_STATE.OPEN) {
+    throw new MinaSettlementError(
+      "CHANNEL_NOT_OPEN",
+      `channel ${bundle.channelId} is not OPEN (channelState=${state.channelState}); claimFromChannel only applies to an OPEN channel.`
+    );
+  }
+  if (nonce <= state.nonceField) {
+    throw new MinaSettlementError(
+      "NONCE_NOT_ADVANCING",
+      `claim nonce ${nonce} does not advance the on-chain nonceField ${state.nonceField} for ${bundle.channelId} (already claimed).`
+    );
+  }
+  const claim = await buildMinaCoSignedClaim({
+    channelId: bundle.channelId,
+    nonce,
+    cumulativeAmount,
+    recipient: bundle.recipient,
+    swapSignerAddress: bundle.swapSignerAddress,
+    depositTotal: state.depositTotal,
+    onChainChannelHash: state.channelHash,
+    recipientPrivateKey: context.recipientPrivateKey,
+    channelNonce,
+    ...context.makerSignature ? { makerSignature: context.makerSignature } : {}
+  });
+  if (claim.makerSignatureMissing || !claim.signatureA || !claim.signatureB) {
+    throw new MinaSettlementError(
+      "MINA_MAKER_COSIGN_REQUIRED",
+      `on-chain claimFromChannel is dual-party: it needs the maker's payment-channel-commitment signature over [commitment, nonce, channelHash] in addition to the recipient's co-signature. The swap-wire claim only carries the maker's balanceProofFieldsMina signature (a different message), so the maker must additionally deliver an on-chain-form co-signature. Recipient co-signature assembled and ready (${bundle.channelId} nonce ${nonce}).`
+    );
+  }
+  const submitter = context.submitter ?? createO1jsMinaClaimSubmitter();
+  const { txHash } = await submitter.claimFromChannel({
+    graphqlUrl,
+    channelId: bundle.channelId,
+    balanceA: claim.balanceA,
+    balanceB: claim.balanceB,
+    salt: claim.salt,
+    nonce: claim.nonce,
+    participantA: claim.participantA,
+    participantB: claim.participantB,
+    channelNonce: claim.channelNonce,
+    signatureA: claim.signatureA,
+    signatureB: claim.signatureB,
+    feePayerPrivateKey: context.feePayerPrivateKey ?? context.recipientPrivateKey,
+    ...context.txFeeNanomina !== void 0 ? { txFeeNanomina: context.txFeeNanomina } : {}
+  });
+  return { txHash };
+}
+var DEFAULT_MINA_TX_FEE_NANOMINA = 100000000n;
+function createO1jsMinaClaimSubmitter() {
+  return {
+    async claimFromChannel(args) {
+      try {
+        const o1js = await import("o1js");
+        const {
+          Mina,
+          PrivateKey,
+          PublicKey,
+          Field,
+          Poseidon,
+          Signature,
+          fetchAccount
+        } = o1js;
+        const zkAppMod = await import("@toon-protocol/mina-zkapp");
+        const PaymentChannel = zkAppMod.PaymentChannel;
+        Mina.setActiveInstance(Mina.Network(args.graphqlUrl));
+        const feePayerKey = PrivateKey.fromBase58(
+          hexToMinaBase58PrivateKey4(args.feePayerPrivateKey)
+        );
+        const feePayerPub = feePayerKey.toPublicKey();
+        await PaymentChannel.compile();
+        const zkAppPub = PublicKey.fromBase58(args.channelId);
+        await fetchAccount({ publicKey: zkAppPub });
+        await fetchAccount({ publicKey: feePayerPub });
+        const zkApp = new PaymentChannel(zkAppPub);
+        const balA = Field(args.balanceA);
+        const balB = Field(args.balanceB);
+        const saltField = Field(args.salt);
+        const newNonce = Field(args.nonce);
+        const channelNonce = Field(args.channelNonce);
+        const newBalanceCommitment = Poseidon.hash([balA, balB, saltField]);
+        const sigA = Signature.fromJSON({
+          r: args.signatureA.r,
+          s: args.signatureA.s
+        });
+        const sigB = Signature.fromJSON({
+          r: args.signatureB.r,
+          s: args.signatureB.s
+        });
+        const partA = PublicKey.fromBase58(args.participantA);
+        const partB = PublicKey.fromBase58(args.participantB);
+        const fee = (args.txFeeNanomina ?? DEFAULT_MINA_TX_FEE_NANOMINA).toString();
+        const txn = await Mina.transaction(
+          { sender: feePayerPub, fee },
+          async () => {
+            await zkApp.claimFromChannel(
+              balA,
+              balB,
+              saltField,
+              sigA,
+              sigB,
+              partA,
+              partB,
+              channelNonce,
+              newBalanceCommitment,
+              newNonce
+            );
+          }
+        );
+        await txn.prove();
+        const sent = await txn.sign([feePayerKey]).send();
+        return { txHash: sent.hash ?? "" };
+      } catch (err) {
+        throw new MinaSettlementError(
+          "PROVING_FAILED",
+          err instanceof Error ? err.message : String(err)
+        );
+      }
+    }
+  };
+}
+
 // src/ToonClient.ts
+function parseMakerMinaSignature(raw) {
+  if (raw && typeof raw.r === "string" && raw.r.length > 0 && typeof raw.s === "string" && raw.s.length > 0) {
+    return { r: raw.r, s: raw.s };
+  }
+  return void 0;
+}
 var ToonClient = class {
   config;
   state = null;
@@ -4846,34 +5317,11 @@ var ToonClient = class {
       const writeData = buildStoreWriteEnvelope(event, options?.proxyPath);
       const destination = options?.destination ?? this.config.destinationAddress;
       const transport = this.getClaimTransport();
-      let claimMessage;
-      if (options?.claim) {
-        claimMessage = this.buildClaimMessageForProof(options.claim);
-      } else if (this.channelManager) {
-        const peerId = this.resolvePeerId(destination);
-        const negotiation = this.peerNegotiations.get(peerId);
-        if (!negotiation) {
-          throw new ToonClientError(
-            `No negotiation metadata for peer "${peerId}" \u2014 was bootstrap completed?`,
-            "PEER_NOT_NEGOTIATED"
-          );
-        }
-        const channelId = await this.channelManager.ensureChannel(
-          peerId,
-          negotiation
-        );
-        const proof = await this.channelManager.signBalanceProof(
-          channelId,
-          BigInt(amount)
-        );
-        const signer = this.channelManager.getSignerForChannel(channelId);
-        claimMessage = signer.buildClaimMessage(proof, this.getPublicKey());
-      } else {
-        throw new ToonClientError(
-          "No claim provided and no channel manager configured",
-          "MISSING_CLAIM"
-        );
-      }
+      const claimMessage = await this.resolveClaimForDestination(
+        destination,
+        BigInt(amount),
+        options?.claim
+      );
       const response = await transport.sendIlpPacketWithClaim(
         {
           destination,
@@ -5080,8 +5528,6 @@ var ToonClient = class {
   }
   /**
    * Shared claim-resolution logic used by `publishEvent` and `sendSwapPacket`.
-   * TODO(12.5 followup): also factor `publishEvent`'s inline claim resolution
-   * to call this helper. Kept duplicated for now to minimize regression risk.
    */
   async resolveClaimForDestination(destination, amount, explicitClaim) {
     if (explicitClaim) {
@@ -5277,6 +5723,54 @@ 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 === "mina") {
+      if (!this.minaPrivateKey) {
+        throw new Error(
+          "Mina signer not configured (no mnemonic / mina-signer) \u2014 cannot co-sign the receive-side claim."
+        );
+      }
+      const makerSignature = parseMakerMinaSignature(
+        this.config.swapMinaMakerSignatures?.[bundle.channelId]
+      );
+      const { txHash } = await submitMinaSettlement(bundle, {
+        recipientPrivateKey: this.minaPrivateKey,
+        ...this.config.minaChannel?.graphqlUrl ? { graphqlUrl: this.config.minaChannel.graphqlUrl } : {},
+        ...makerSignature ? { makerSignature } : {}
+      });
+      return { txHash };
+    }
+    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");
@@ -5875,6 +6369,328 @@ 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/swap/preimage-retention.ts
+function copy(entry) {
+  return {
+    packetIndex: entry.packetIndex,
+    preimage: Uint8Array.from(entry.preimage),
+    condition: Uint8Array.from(entry.condition),
+    retainedAt: entry.retainedAt
+  };
+}
+var InMemoryPreimageRetentionStore = class {
+  entries = /* @__PURE__ */ new Map();
+  retain(entry) {
+    this.entries.set(entry.packetIndex, copy(entry));
+  }
+  get(packetIndex) {
+    const entry = this.entries.get(packetIndex);
+    return entry ? copy(entry) : void 0;
+  }
+  take(packetIndex) {
+    const entry = this.entries.get(packetIndex);
+    if (!entry) return void 0;
+    this.entries.delete(packetIndex);
+    return copy(entry);
+  }
+  size() {
+    return this.entries.size;
+  }
+  clear() {
+    this.entries.clear();
+  }
+};
+
+// src/swap/atomic-reveal.ts
+function rollbackWatermark(store, chain, channelId, prior) {
+  if (prior === void 0) {
+    store.delete(chain, channelId);
+  } else {
+    store.save(prior);
+  }
+}
+async function ingestAndReveal(params) {
+  const { reveal, preimages, claims, store, ...shared } = params;
+  const revealed = [];
+  const rolledBack = [];
+  const rejected = [];
+  const legacy = [];
+  let valueRevealed = 0n;
+  for (const claim of claims) {
+    const hasMeta = hasSettlementMetadata(claim);
+    const chain = hasMeta ? claim.pair.to.chain : void 0;
+    const channelId = hasMeta ? claim.channelId : void 0;
+    const prior = chain !== void 0 && channelId !== void 0 ? store.load(chain, channelId) : void 0;
+    const ingest = ingestReceivedClaims({ ...shared, claims: [claim], store });
+    if (ingest.legacy.length > 0) {
+      legacy.push(claim);
+      continue;
+    }
+    const rejection = ingest.rejected[0];
+    if (rejection) {
+      rejected.push(rejection);
+      continue;
+    }
+    const verified = ingest.verified[0];
+    if (!verified || chain === void 0 || channelId === void 0) continue;
+    const advance = verified.watermarkAdvance;
+    const preimage = preimages?.take(claim.packetIndex);
+    let outcome;
+    try {
+      outcome = await reveal(claim, preimage);
+    } catch (err) {
+      outcome = {
+        decision: "withheld",
+        reason: err instanceof Error ? err.message : String(err)
+      };
+    }
+    if (outcome.decision === "revealed") {
+      revealed.push({ claim, watermarkAdvance: advance });
+      valueRevealed += advance;
+      continue;
+    }
+    rollbackWatermark(store, chain, channelId, prior);
+    rolledBack.push({
+      claim,
+      watermarkAdvance: advance,
+      reason: outcome.reason ?? "reveal withheld"
+    });
+  }
+  return { revealed, rolledBack, rejected, legacy, valueRevealed };
+}
+
 // src/faucet.ts
 function defaultFaucetTimeout(chain) {
   return chain === "mina" ? 12e4 : 3e4;
@@ -6854,7 +7670,7 @@ import {
   createDecipheriv,
   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;
@@ -6881,14 +7697,14 @@ function encryptMnemonic2(mnemonic, password) {
   }
   const salt = randomBytes2(SALT_LEN);
   const iv = randomBytes2(IV_LEN);
-  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 cipher = createCipheriv("aes-256-gcm", key, iv, {
+    const cipher = createCipheriv("aes-256-gcm", key2, iv, {
       authTagLength: AUTH_TAG_LEN
     });
     const ciphertext = Buffer.concat([
@@ -6904,7 +7720,7 @@ function encryptMnemonic2(mnemonic, password) {
       version: 1
     };
   } finally {
-    key.fill(0);
+    key2.fill(0);
   }
 }
 function decryptMnemonic2(encrypted, password) {
@@ -6919,14 +7735,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);
@@ -6942,7 +7758,7 @@ function decryptMnemonic2(encrypted, password) {
       );
     }
   } finally {
-    key.fill(0);
+    key2.fill(0);
   }
 }
 function generateKeystore(path, password) {
@@ -6965,7 +7781,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);
@@ -6976,7 +7792,7 @@ 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
   });
@@ -6998,10 +7814,15 @@ export {
   ILP_CLAIM_HEADER,
   ILP_CLAIM_WRAPPED_HEADER,
   ILP_PEER_ID_HEADER,
+  InMemoryPreimageRetentionStore,
+  InMemoryReceivedClaimStore,
+  JsonFileReceivedClaimStore,
   KeyManager,
   KindRegistry,
   MIME_A2UI,
   MIME_MCP_APP,
+  MINA_CHANNEL_STATE,
+  MinaSettlementError,
   MinaSigner,
   NetworkError,
   OnChainChannelClient,
@@ -7018,11 +7839,15 @@ export {
   buildBackupEvent,
   buildBackupFilter,
   buildConsentRequest,
+  buildMinaCoSignedClaim,
   buildRendererEventTemplate,
   buildSettlementInfo,
   buildStoreWriteEnvelope,
+  buildSwapSettlements,
   buildUiCoordinate,
   classifyIntent,
+  createO1jsMinaClaimSubmitter,
+  decodeEvmSettlementTx,
   decryptMnemonic2 as decryptMnemonic,
   defaultFaucetTimeout,
   deriveFromNsec,
@@ -7030,6 +7855,7 @@ export {
   deriveNostrKeyFromMnemonic,
   deterministicGenerator,
   encryptMnemonic2 as encryptMnemonic,
+  entryToAccumulatedClaim,
   extractArweaveTxId,
   extractUiResource,
   fulfillmentMatchesCondition,
@@ -7040,8 +7866,11 @@ export {
   getNetworkStatus,
   getUiCoordinate,
   guardedRenderDispatch,
+  hasSettlementMetadata,
   httpEndpointToBtpUrl,
   importKeystore,
+  ingestAndReveal,
+  ingestReceivedClaims,
   isInsufficientGasError,
   isPrfSupported,
   isTrustDowngrade,
@@ -7049,6 +7878,7 @@ export {
   loadKeystore,
   mintExecutionCondition,
   parseBackupPayload,
+  parseEvmChainId2 as parseEvmChainId,
   parseFulfillHttp,
   parseFulfillHttpBytes,
   parseHttpResponse,
@@ -7061,6 +7891,7 @@ export {
   readEvmNativeBalance,
   readEvmTokenBalance,
   readMinaBalance,
+  readMinaChannelState,
   readMinaDepositTotal,
   readSolanaNativeBalance,
   readSolanaTokenBalance,
@@ -7074,6 +7905,8 @@ export {
   selectIlpTransport,
   selectLatestAddressable,
   serializeHttpRequest,
+  submitEvmSettlement,
+  submitMinaSettlement,
   validateConfig,
   validateMnemonic,
   verifyRendererTrust,