@toon-protocol/client 0.18.0 → 0.19.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";
@@ -4731,7 +4774,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 +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,
@@ -5250,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) {
@@ -5460,6 +5736,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.`
@@ -6309,6 +6601,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;
@@ -7432,12 +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,
@@ -7454,12 +7839,14 @@ export {
   buildBackupEvent,
   buildBackupFilter,
   buildConsentRequest,
+  buildMinaCoSignedClaim,
   buildRendererEventTemplate,
   buildSettlementInfo,
   buildStoreWriteEnvelope,
   buildSwapSettlements,
   buildUiCoordinate,
   classifyIntent,
+  createO1jsMinaClaimSubmitter,
   decodeEvmSettlementTx,
   decryptMnemonic2 as decryptMnemonic,
   defaultFaucetTimeout,
@@ -7482,6 +7869,7 @@ export {
   hasSettlementMetadata,
   httpEndpointToBtpUrl,
   importKeystore,
+  ingestAndReveal,
   ingestReceivedClaims,
   isInsufficientGasError,
   isPrfSupported,
@@ -7503,6 +7891,7 @@ export {
   readEvmNativeBalance,
   readEvmTokenBalance,
   readMinaBalance,
+  readMinaChannelState,
   readMinaDepositTotal,
   readSolanaNativeBalance,
   readSolanaTokenBalance,
@@ -7517,6 +7906,7 @@ export {
   selectLatestAddressable,
   serializeHttpRequest,
   submitEvmSettlement,
+  submitMinaSettlement,
   validateConfig,
   validateMnemonic,
   verifyRendererTrust,