@toon-protocol/client 0.18.0 → 0.20.0

package/dist/index.js

@@ -3409,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, {
@@ -3434,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";
@@ -4634,6 +4677,7 @@ function buildSwapSettlements(params) {
         claims: [entryToAccumulatedClaim(entry)],
         signers: { [entry.chain]: signer },
         recipients: { [entry.chain]: entry.recipient },
+        ...params.verifySignatures !== void 0 ? { verifySignatures: params.verifySignatures } : {},
         ...params.minaSignerClient ? { minaSignerClient: params.minaSignerClient } : {}
       });
       const firstRejected = result.rejected[0];
@@ -4681,7 +4725,9 @@ function decodeEvmSettlementTx(bundle) {
   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)}`);
+    throw new Error(
+      `settlement tx "to" is not a 20-byte address: ${String(to)}`
+    );
   }
   return { to, data: data === "0x" ? "0x" : data, chainId };
 }
@@ -4698,7 +4744,10 @@ async function submitEvmSettlement(bundle, params) {
     nativeCurrency: { name: "ETH", symbol: "ETH", decimals: 18 },
     rpcUrls: { default: { http: [params.rpcUrl] } }
   });
-  const publicClient = createPublicClient3({ chain, transport: http3(params.rpcUrl) });
+  const publicClient = createPublicClient3({
+    chain,
+    transport: http3(params.rpcUrl)
+  });
   const [nonce, gasPrice, gas] = await Promise.all([
     publicClient.getTransactionCount({
       address: params.account.address,
@@ -4731,7 +4780,265 @@ async function submitEvmSettlement(bundle, params) {
   }
 }
 
+// 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;
@@ -5016,34 +5323,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,
@@ -5250,8 +5534,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) {
@@ -5460,6 +5742,22 @@ var ToonClient = class {
    * 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.`
@@ -6171,6 +6469,116 @@ function fromJson(entry) {
 import {
   verifyAccumulatedClaim
 } from "@toon-protocol/sdk";
+
+// src/swap/evm-claim-digest.ts
+import {
+  hashTypedData
+} from "viem";
+import { secp256k1 } from "@noble/curves/secp256k1.js";
+import { keccak_256 } from "@noble/hashes/sha3.js";
+import { hexToBytes, bytesToHex as bytesToHex2 } from "@noble/hashes/utils.js";
+var ROLLING_SWAP_DOMAIN_NAME = "RollingSwapChannel";
+var ROLLING_SWAP_DOMAIN_VERSION = "2";
+var CLAIM_TYPEHASH = "0xa0c8262c1a8615f7674d3af796b14d19672d3634f89c6093502ab35c0afe2d91";
+var COOP_CLOSE_TYPEHASH = "0xa5753389755fea51cd5016d7b02b508ac03f2e822d9a7ee345ec45b36574ff9f";
+var CLAIM_TYPES = {
+  ClaimBalanceProof: [
+    { name: "channelId", type: "bytes32" },
+    { name: "cumulativeAmount", type: "uint256" },
+    { name: "nonce", type: "uint256" },
+    { name: "recipient", type: "address" }
+  ]
+};
+var COOP_CLOSE_TYPES = {
+  CooperativeClose: [
+    { name: "channelId", type: "bytes32" },
+    { name: "cumulativeAmount", type: "uint256" },
+    { name: "nonce", type: "uint256" }
+  ]
+};
+function normalizeAddress(addr) {
+  return addr.toLowerCase();
+}
+function domainOf(ctx) {
+  return {
+    name: ROLLING_SWAP_DOMAIN_NAME,
+    version: ROLLING_SWAP_DOMAIN_VERSION,
+    chainId: ctx.chainId,
+    verifyingContract: normalizeAddress(ctx.verifyingContract)
+  };
+}
+function evmClaimDigest(ctx, message) {
+  return hashTypedData({
+    domain: domainOf(ctx),
+    types: CLAIM_TYPES,
+    primaryType: "ClaimBalanceProof",
+    message: {
+      channelId: message.channelId,
+      cumulativeAmount: message.cumulativeAmount,
+      nonce: message.nonce,
+      recipient: normalizeAddress(message.recipient)
+    }
+  });
+}
+function evmCooperativeCloseDigest(ctx, message) {
+  return hashTypedData({
+    domain: domainOf(ctx),
+    types: COOP_CLOSE_TYPES,
+    primaryType: "CooperativeClose",
+    message: {
+      channelId: message.channelId,
+      cumulativeAmount: message.cumulativeAmount,
+      nonce: message.nonce
+    }
+  });
+}
+var SIG_BYTES = 65;
+function signatureToBytes(sig) {
+  if (typeof sig !== "string") return sig;
+  const hex = sig.startsWith("0x") ? sig.slice(2) : sig;
+  return hexToBytes(hex);
+}
+function recoverEvmClaimSigner(ctx, message, signature) {
+  const bytes = signatureToBytes(signature);
+  if (bytes.length !== SIG_BYTES) {
+    throw new Error(
+      `EVM signature must be 65 bytes (r||s||v), got ${bytes.length}`
+    );
+  }
+  const v = bytes[64];
+  if (v !== 27 && v !== 28) {
+    throw new Error(`EVM signature v must be 27 or 28, got ${v}`);
+  }
+  const digest = evmClaimDigest(ctx, message).slice(2);
+  const recovered = secp256k1.Signature.fromBytes(bytes.slice(0, 64), "compact").addRecoveryBit(v - 27).recoverPublicKey(hexToBytes(digest));
+  const uncompressed = recovered.toBytes(false);
+  const addrHash = keccak_256(uncompressed.slice(1));
+  return `0x${bytesToHex2(addrHash.slice(-20))}`;
+}
+function verifyEvmClaimSignature(params) {
+  let recovered;
+  try {
+    recovered = recoverEvmClaimSigner(
+      params.ctx,
+      params.message,
+      params.signature
+    );
+  } catch (err) {
+    return {
+      valid: false,
+      reason: `SIGNATURE_INVALID: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+  if (recovered.toLowerCase() !== params.expectedSigner.toLowerCase()) {
+    return {
+      valid: false,
+      reason: `SIGNER_MISMATCH: recovered ${recovered}, expected ${params.expectedSigner}`
+    };
+  }
+  return { valid: true, recovered };
+}
+
+// src/swap/received-claims.ts
 function hasSettlementMetadata(claim) {
   return claim.channelId !== void 0 && claim.nonce !== void 0 && claim.cumulativeAmount !== void 0 && claim.recipient !== void 0 && claim.swapSignerAddress !== void 0;
 }
@@ -6225,11 +6633,49 @@ function ingestReceivedClaims(params) {
       continue;
     }
     const expectedSigner = params.expectedSignerAddress ?? claim.swapSignerAddress;
-    const sig = verifyAccumulatedClaim(
-      claim,
-      { address: expectedSigner },
-      params.minaSignerClient
-    );
+    let sig;
+    if (chain.startsWith("evm")) {
+      const chainId = parseEvmChainId2(chain);
+      const verifyingContract = params.tokenNetworks?.[chain];
+      if (chainId === void 0 || !verifyingContract) {
+        reject(
+          claim,
+          "MISSING_CHAIN_CONFIG",
+          `EVM v2 balance-proof verification for ${chain} needs a numeric chain id in the chain key AND tokenNetworks["${chain}"] (the RollingSwapChannel / verifyingContract) to reconstruct the EIP-712 domain; supply it from the connector/swap session context.`
+        );
+        continue;
+      }
+      let msgNonce;
+      let msgCumulative;
+      try {
+        msgNonce = BigInt(claim.nonce);
+        msgCumulative = BigInt(claim.cumulativeAmount);
+      } catch {
+        reject(
+          claim,
+          "MALFORMED_METADATA",
+          `nonce "${claim.nonce}" / cumulativeAmount "${claim.cumulativeAmount}" are not decimal integers`
+        );
+        continue;
+      }
+      sig = verifyEvmClaimSignature({
+        ctx: { chainId, verifyingContract },
+        message: {
+          channelId: claim.channelId,
+          cumulativeAmount: msgCumulative,
+          nonce: msgNonce,
+          recipient: claim.recipient
+        },
+        signature: claim.claimBytes,
+        expectedSigner
+      });
+    } else {
+      sig = verifyAccumulatedClaim(
+        claim,
+        { address: expectedSigner },
+        params.minaSignerClient
+      );
+    }
     if (!sig.valid) {
       reject(claim, signatureRejectionCode(sig.reason), sig.reason);
       continue;
@@ -6309,6 +6755,96 @@ function ingestReceivedClaims(params) {
   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;
@@ -6507,14 +7043,14 @@ function fromBase642(b64) {
   }
   return bytes;
 }
-function hexToBytes(hex) {
+function hexToBytes2(hex) {
   const bytes = new Uint8Array(hex.length / 2);
   for (let i = 0; i < hex.length; i += 2) {
     bytes[i / 2] = parseInt(hex.slice(i, i + 2), 16);
   }
   return bytes;
 }
-function bytesToHex2(bytes) {
+function bytesToHex3(bytes) {
   return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
 }
 
@@ -6846,7 +7382,7 @@ var KeyManager = class {
     const mnemonic = generateMnemonic();
     const identity = await deriveFullIdentity(mnemonic);
     const prfSalt = crypto.getRandomValues(new Uint8Array(32));
-    const userIdBytes = hexToBytes(identity.nostr.pubkey);
+    const userIdBytes = hexToBytes2(identity.nostr.pubkey);
     const registration = await registerPasskey({
       rpId: this.config.rpId,
       rpName: this.config.rpName,
@@ -6888,7 +7424,7 @@ var KeyManager = class {
         "Passkey did not return a userHandle. Cannot determine Nostr pubkey for recovery."
       );
     }
-    const pubkey = bytesToHex2(discovery.userHandle);
+    const pubkey = bytesToHex3(discovery.userHandle);
     const vault = await fetchBackupFromRelays(pubkey, this.config.relayUrls);
     if (!vault) {
       throw new Error(
@@ -6926,7 +7462,7 @@ var KeyManager = class {
     }
     const identity = await deriveFullIdentity(mnemonic);
     const prfSalt = crypto.getRandomValues(new Uint8Array(32));
-    const userIdBytes = hexToBytes(identity.nostr.pubkey);
+    const userIdBytes = hexToBytes2(identity.nostr.pubkey);
     const registration = await registerPasskey({
       rpId: this.config.rpId,
       rpName: this.config.rpName,
@@ -6957,7 +7493,7 @@ var KeyManager = class {
     const identity = deriveFromNsec(secretKey);
     if (isPrfSupported()) {
       const prfSalt = crypto.getRandomValues(new Uint8Array(32));
-      const userIdBytes = hexToBytes(identity.nostr.pubkey);
+      const userIdBytes = hexToBytes2(identity.nostr.pubkey);
       try {
         const registration = await registerPasskey({
           rpId: this.config.rpId,
@@ -6968,7 +7504,7 @@ var KeyManager = class {
         });
         const kek = await deriveKek(registration.prfOutput);
         const credIdHash = await hashCredentialId(registration.credentialId);
-        const hexKey = bytesToHex2(secretKey);
+        const hexKey = bytesToHex3(secretKey);
         this.vault = await createVault(hexKey, kek, credIdHash, prfSalt);
         this.activeCredentialIdHash = credIdHash;
         await this.saveToLocalStorage();
@@ -6987,7 +7523,7 @@ var KeyManager = class {
       throw new Error("No active identity \u2014 call create() or recover() first");
     }
     const prfSalt = crypto.getRandomValues(new Uint8Array(32));
-    const userIdBytes = hexToBytes(this.identity.nostr.pubkey);
+    const userIdBytes = hexToBytes2(this.identity.nostr.pubkey);
     const registration = await registerPasskey({
       rpId: this.config.rpId,
       rpName: this.config.rpName,
@@ -7417,7 +7953,9 @@ function writeKeystoreFile(path, keystore) {
 }
 export {
   BtpRuntimeClient,
+  CLAIM_TYPEHASH,
   CONDITION_LENGTH,
+  COOP_CLOSE_TYPEHASH,
   ChannelFundingError,
   ChannelManager,
   ConnectorError,
@@ -7432,15 +7970,20 @@ 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,
+  ROLLING_SWAP_DOMAIN_NAME,
+  ROLLING_SWAP_DOMAIN_VERSION,
   RendererPinStore,
   SolanaSigner,
   ToonClient,
@@ -7454,12 +7997,14 @@ export {
   buildBackupEvent,
   buildBackupFilter,
   buildConsentRequest,
+  buildMinaCoSignedClaim,
   buildRendererEventTemplate,
   buildSettlementInfo,
   buildStoreWriteEnvelope,
   buildSwapSettlements,
   buildUiCoordinate,
   classifyIntent,
+  createO1jsMinaClaimSubmitter,
   decodeEvmSettlementTx,
   decryptMnemonic2 as decryptMnemonic,
   defaultFaucetTimeout,
@@ -7469,6 +8014,8 @@ export {
   deterministicGenerator,
   encryptMnemonic2 as encryptMnemonic,
   entryToAccumulatedClaim,
+  evmClaimDigest,
+  evmCooperativeCloseDigest,
   extractArweaveTxId,
   extractUiResource,
   fulfillmentMatchesCondition,
@@ -7482,6 +8029,7 @@ export {
   hasSettlementMetadata,
   httpEndpointToBtpUrl,
   importKeystore,
+  ingestAndReveal,
   ingestReceivedClaims,
   isInsufficientGasError,
   isPrfSupported,
@@ -7503,10 +8051,12 @@ export {
   readEvmNativeBalance,
   readEvmTokenBalance,
   readMinaBalance,
+  readMinaChannelState,
   readMinaDepositTotal,
   readSolanaNativeBalance,
   readSolanaTokenBalance,
   readWalletBalances,
+  recoverEvmClaimSigner,
   renderDeterministicHtml,
   renderDispatch,
   requestBlobStorage,
@@ -7517,8 +8067,10 @@ export {
   selectLatestAddressable,
   serializeHttpRequest,
   submitEvmSettlement,
+  submitMinaSettlement,
   validateConfig,
   validateMnemonic,
+  verifyEvmClaimSignature,
   verifyRendererTrust,
   withRetry,
   writeKeystoreFile