@toon-protocol/client 0.17.0 → 0.18.0

package/dist/index.js

@@ -153,7 +153,7 @@ async function deriveSolanaKey(seed, accountIndex = 0) {
   const { ed25519: ed255194 } = await import("@noble/curves/ed25519.js");
   const encoder = new TextEncoder();
   let I = hmac(sha512, encoder.encode("ed25519 seed"), seed);
-  let key = I.slice(0, 32);
+  let key2 = I.slice(0, 32);
   let chainCode = I.slice(32);
   const indices = [
     2147483692,
@@ -168,18 +168,18 @@ async function deriveSolanaKey(seed, accountIndex = 0) {
   for (const index of indices) {
     const data = new Uint8Array(37);
     data[0] = 0;
-    data.set(key, 1);
+    data.set(key2, 1);
     data[33] = index >>> 24 & 255;
     data[34] = index >>> 16 & 255;
     data[35] = index >>> 8 & 255;
     data[36] = index & 255;
     I = hmac(sha512, chainCode, data);
-    key = I.slice(0, 32);
+    key2 = I.slice(0, 32);
     chainCode = I.slice(32);
   }
-  const publicKeyBytes = ed255194.getPublicKey(key);
+  const publicKeyBytes = ed255194.getPublicKey(key2);
   const keypair = new Uint8Array(64);
-  keypair.set(key, 0);
+  keypair.set(key2, 0);
   keypair.set(publicKeyBytes, 32);
   const publicKey = toBase58(publicKeyBytes);
   return { secretKey: keypair, publicKey };
@@ -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)) {
@@ -4267,8 +4271,8 @@ async function requestBlobStorage(client, secretKey, params) {
   };
 }
 function extractArweaveTxId(base64Data) {
-  const http3 = parseFulfillHttp(base64Data);
-  if (!http3.isHttp) {
+  const http4 = parseFulfillHttp(base64Data);
+  if (!http4.isHttp) {
     const legacy = decodeUtf8(fromBase64(base64Data));
     if (!ARWEAVE_TX_ID_REGEX.test(legacy)) {
       throw new Error(
@@ -4277,18 +4281,18 @@ function extractArweaveTxId(base64Data) {
     }
     return legacy;
   }
-  if (http3.status < 200 || http3.status >= 300) {
-    const detail = http3.body ? ` - ${http3.body}` : "";
+  if (http4.status < 200 || http4.status >= 300) {
+    const detail = http4.body ? ` - ${http4.body}` : "";
     throw new Error(
-      `Blob upload failed: DVM returned HTTP ${http3.status} ${http3.statusText}`.trimEnd() + detail
+      `Blob upload failed: DVM returned HTTP ${http4.status} ${http4.statusText}`.trimEnd() + detail
     );
   }
   let parsed;
   try {
-    parsed = JSON.parse(http3.body);
+    parsed = JSON.parse(http4.body);
   } catch {
     throw new Error(
-      `Blob upload response body was not valid JSON: "${http3.body}"`
+      `Blob upload response body was not valid JSON: "${http4.body}"`
     );
   }
   const body = parsed;
@@ -4306,7 +4310,7 @@ function extractArweaveTxId(base64Data) {
     }
   }
   throw new Error(
-    `Blob upload response did not contain a valid Arweave tx ID: "${http3.body}"`
+    `Blob upload response did not contain a valid Arweave tx ID: "${http4.body}"`
   );
 }
 
@@ -4561,6 +4565,172 @@ function parseHttpResponse(bytes) {
   );
 }
 
+// src/swap/settle-received-claims.ts
+import {
+  buildSettlementTx,
+  SettlementTxError
+} from "@toon-protocol/sdk";
+import {
+  createPublicClient as createPublicClient3,
+  defineChain as defineChain3,
+  fromRlp,
+  http as http3
+} from "viem";
+function entryToAccumulatedClaim(entry) {
+  return {
+    packetIndex: 0,
+    sourceAmount: 0n,
+    targetAmount: entry.cumulativeAmount,
+    claimBytes: entry.claimBytes,
+    swapEphemeralPubkey: "",
+    ...entry.claimId !== void 0 ? { claimId: entry.claimId } : {},
+    pair: entry.pair,
+    receivedAt: entry.receivedAt,
+    channelId: entry.channelId,
+    nonce: entry.nonce.toString(),
+    cumulativeAmount: entry.cumulativeAmount.toString(),
+    recipient: entry.recipient,
+    swapSignerAddress: entry.swapSignerAddress
+  };
+}
+function parseEvmChainId2(chain) {
+  const parts = chain.split(":");
+  const raw = parts.length >= 3 ? parts[2] : parts[1];
+  const chainId = Number.parseInt(raw ?? "", 10);
+  return Number.isInteger(chainId) && chainId > 0 ? chainId : void 0;
+}
+function buildSwapSettlements(params) {
+  return params.entries.map((entry) => {
+    const base = { chain: entry.chain, channelId: entry.channelId };
+    const signer = { address: entry.swapSignerAddress };
+    const contract = params.tokenNetworks?.[entry.chain];
+    if (entry.chain.startsWith("evm")) {
+      const chainId = parseEvmChainId2(entry.chain);
+      if (!contract || chainId === void 0) {
+        return {
+          ...base,
+          error: {
+            code: "MISSING_CHAIN_CONFIG",
+            message: `EVM settlement for ${entry.chain} needs tokenNetworks["${entry.chain}"] (TokenNetwork contract) and a numeric chain id in the chain key.`
+          }
+        };
+      }
+      signer.contractAddress = contract;
+      signer.chainId = chainId;
+    } else if (entry.chain.startsWith("solana")) {
+      if (!contract) {
+        return {
+          ...base,
+          error: {
+            code: "MISSING_CHAIN_CONFIG",
+            message: `Solana settlement for ${entry.chain} needs tokenNetworks["${entry.chain}"] (programId).`
+          }
+        };
+      }
+      signer.programId = contract;
+    }
+    try {
+      const result = buildSettlementTx({
+        claims: [entryToAccumulatedClaim(entry)],
+        signers: { [entry.chain]: signer },
+        recipients: { [entry.chain]: entry.recipient },
+        ...params.minaSignerClient ? { minaSignerClient: params.minaSignerClient } : {}
+      });
+      const firstRejected = result.rejected[0];
+      if (firstRejected) {
+        return {
+          ...base,
+          error: {
+            code: firstRejected.reason,
+            message: firstRejected.details ?? `stored claim for ${entry.chain}/${entry.channelId} failed settlement re-verification`
+          }
+        };
+      }
+      const bundle = result.bundles[0];
+      if (!bundle) {
+        return {
+          ...base,
+          error: {
+            code: "NO_BUNDLE",
+            message: `buildSettlementTx produced no bundle for ${entry.chain}/${entry.channelId}`
+          }
+        };
+      }
+      return { ...base, bundle };
+    } catch (err) {
+      const code = err instanceof SettlementTxError ? err.code : "BUILD_FAILED";
+      return {
+        ...base,
+        error: {
+          code,
+          message: err instanceof Error ? err.message : String(err)
+        }
+      };
+    }
+  });
+}
+function decodeEvmSettlementTx(bundle) {
+  const fields = fromRlp(bundle.unsignedTxBytes, "hex");
+  if (!Array.isArray(fields) || fields.length !== 9) {
+    throw new Error(
+      `settlement bundle RLP is not a 9-field unsigned EVM tx (got ${Array.isArray(fields) ? fields.length : typeof fields})`
+    );
+  }
+  const to = fields[3];
+  const data = fields[5];
+  const chainIdHex = fields[6];
+  const chainId = Number.parseInt(chainIdHex === "0x" ? "0x0" : chainIdHex, 16);
+  if (typeof to !== "string" || to.length !== 42) {
+    throw new Error(`settlement tx "to" is not a 20-byte address: ${String(to)}`);
+  }
+  return { to, data: data === "0x" ? "0x" : data, chainId };
+}
+async function submitEvmSettlement(bundle, params) {
+  if (bundle.chainKind !== "evm") {
+    throw new Error(
+      `submitEvmSettlement only submits evm bundles (got ${bundle.chainKind} for ${bundle.chain})`
+    );
+  }
+  const { to, data, chainId } = decodeEvmSettlementTx(bundle);
+  const chain = defineChain3({
+    id: chainId,
+    name: bundle.chain,
+    nativeCurrency: { name: "ETH", symbol: "ETH", decimals: 18 },
+    rpcUrls: { default: { http: [params.rpcUrl] } }
+  });
+  const publicClient = createPublicClient3({ chain, transport: http3(params.rpcUrl) });
+  const [nonce, gasPrice, gas] = await Promise.all([
+    publicClient.getTransactionCount({
+      address: params.account.address,
+      blockTag: "pending"
+    }),
+    publicClient.getGasPrice(),
+    publicClient.estimateGas({ account: params.account.address, to, data })
+  ]);
+  const signed = await params.account.signTransaction({
+    type: "legacy",
+    chainId,
+    nonce,
+    gasPrice,
+    gas,
+    to,
+    value: 0n,
+    data
+  });
+  const txHash = await publicClient.sendRawTransaction({
+    serializedTransaction: signed
+  });
+  try {
+    const receipt = await publicClient.waitForTransactionReceipt({
+      hash: txHash,
+      timeout: params.timeoutMs ?? 6e4
+    });
+    return { txHash, status: receipt.status };
+  } catch {
+    return { txHash };
+  }
+}
+
 // src/ToonClient.ts
 var ToonClient = class {
   config;
@@ -5277,6 +5447,38 @@ var ToonClient = class {
     this.channelManager.setChannelSettled(channelId, nowSec);
     return { channelId, ...r.txHash ? { txHash: r.txHash } : {} };
   }
+  /**
+   * Submit a receive-side swap settlement bundle on-chain (toon-client#352).
+   * The bundle comes from the sdk's `buildSettlementTx` over persisted,
+   * verified chain-B claims (`buildSwapSettlements`); this signs it with the
+   * client's EVM account (the claim recipient) and broadcasts it.
+   *
+   * Env-gated seam: EVM only, and only when `chainRpcUrls[bundle.chain]` is
+   * configured — otherwise this throws a clear config error and callers
+   * surface a built-not-submitted result. Solana submission and the Mina
+   * receive-side co-sign path are explicit follow-ups (see
+   * swap/settle-received-claims.ts module doc).
+   */
+  async settleSwapBundle(bundle) {
+    if (bundle.chainKind !== "evm") {
+      throw new Error(
+        `Swap settlement submission for ${bundle.chainKind} (${bundle.chain}) is not wired yet \u2014 EVM only today.`
+      );
+    }
+    const rpcUrl = this.config.chainRpcUrls?.[bundle.chain];
+    if (!rpcUrl) {
+      throw new Error(
+        `No RPC URL configured for chain "${bundle.chain}" \u2014 add it to chainRpcUrls to enable swap settlement submission.`
+      );
+    }
+    if (!this.evmSigner) {
+      throw new Error("EVM signer not configured (no evmPrivateKey/mnemonic).");
+    }
+    return submitEvmSettlement(bundle, {
+      rpcUrl,
+      account: this.evmSigner.account
+    });
+  }
   /** Where a tracked channel sits in the withdraw journey. */
   getChannelCloseState(channelId) {
     if (!this.channelManager) throw new Error("ChannelManager not initialized");
@@ -5875,6 +6077,238 @@ var HttpConnectorAdmin = class {
   }
 };
 
+// src/channel/ReceivedClaimStore.ts
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, existsSync as existsSync2, mkdirSync } from "fs";
+import { dirname } from "path";
+function key(chain, channelId) {
+  return `${chain}|${channelId}`;
+}
+var JsonFileReceivedClaimStore = class {
+  filePath;
+  constructor(filePath) {
+    this.filePath = filePath;
+  }
+  save(entry) {
+    const data = this.readFile();
+    data[key(entry.chain, entry.channelId)] = {
+      chain: entry.chain,
+      channelId: entry.channelId,
+      nonce: entry.nonce.toString(),
+      cumulativeAmount: entry.cumulativeAmount.toString(),
+      recipient: entry.recipient,
+      swapSignerAddress: entry.swapSignerAddress,
+      claimBytes: Buffer.from(entry.claimBytes).toString("base64"),
+      ...entry.claimId !== void 0 ? { claimId: entry.claimId } : {},
+      pair: entry.pair,
+      receivedAt: entry.receivedAt,
+      updatedAt: entry.updatedAt,
+      ...entry.settledAt !== void 0 ? { settledAt: entry.settledAt } : {},
+      ...entry.settledNonce !== void 0 ? { settledNonce: entry.settledNonce.toString() } : {},
+      ...entry.settleTxHash !== void 0 ? { settleTxHash: entry.settleTxHash } : {}
+    };
+    this.writeFile(data);
+  }
+  load(chain, channelId) {
+    const entry = this.readFile()[key(chain, channelId)];
+    return entry ? fromJson(entry) : void 0;
+  }
+  list() {
+    return Object.values(this.readFile()).map(fromJson);
+  }
+  delete(chain, channelId) {
+    const data = this.readFile();
+    const { [key(chain, channelId)]: _, ...rest } = data;
+    this.writeFile(rest);
+  }
+  readFile() {
+    if (!existsSync2(this.filePath)) {
+      return {};
+    }
+    const raw = readFileSync2(this.filePath, "utf-8");
+    return JSON.parse(raw);
+  }
+  writeFile(data) {
+    mkdirSync(dirname(this.filePath), { recursive: true });
+    writeFileSync2(this.filePath, JSON.stringify(data, null, 2), "utf-8");
+  }
+};
+var InMemoryReceivedClaimStore = class {
+  entries = /* @__PURE__ */ new Map();
+  save(entry) {
+    this.entries.set(key(entry.chain, entry.channelId), { ...entry });
+  }
+  load(chain, channelId) {
+    const entry = this.entries.get(key(chain, channelId));
+    return entry ? { ...entry } : void 0;
+  }
+  list() {
+    return [...this.entries.values()].map((e) => ({ ...e }));
+  }
+  delete(chain, channelId) {
+    this.entries.delete(key(chain, channelId));
+  }
+};
+function fromJson(entry) {
+  return {
+    chain: entry.chain,
+    channelId: entry.channelId,
+    nonce: BigInt(entry.nonce),
+    cumulativeAmount: BigInt(entry.cumulativeAmount),
+    recipient: entry.recipient,
+    swapSignerAddress: entry.swapSignerAddress,
+    claimBytes: new Uint8Array(Buffer.from(entry.claimBytes, "base64")),
+    ...entry.claimId !== void 0 ? { claimId: entry.claimId } : {},
+    pair: entry.pair,
+    receivedAt: entry.receivedAt,
+    updatedAt: entry.updatedAt,
+    ...entry.settledAt !== void 0 ? { settledAt: entry.settledAt } : {},
+    ...entry.settledNonce !== void 0 ? { settledNonce: BigInt(entry.settledNonce) } : {},
+    ...entry.settleTxHash !== void 0 ? { settleTxHash: entry.settleTxHash } : {}
+  };
+}
+
+// src/swap/received-claims.ts
+import {
+  verifyAccumulatedClaim
+} from "@toon-protocol/sdk";
+function hasSettlementMetadata(claim) {
+  return claim.channelId !== void 0 && claim.nonce !== void 0 && claim.cumulativeAmount !== void 0 && claim.recipient !== void 0 && claim.swapSignerAddress !== void 0;
+}
+function sameAddress(chain, a, b) {
+  return chain.startsWith("evm") ? a.toLowerCase() === b.toLowerCase() : a === b;
+}
+function signatureRejectionCode(reason) {
+  if (reason.startsWith("SIGNER_MISMATCH")) return "SIGNER_MISMATCH";
+  if (reason.startsWith("MINA_VERIFICATION_UNSUPPORTED"))
+    return "MINA_VERIFICATION_UNSUPPORTED";
+  if (reason.startsWith("UNSUPPORTED_CHAIN")) return "UNSUPPORTED_CHAIN";
+  return "SIGNATURE_INVALID";
+}
+function ingestReceivedClaims(params) {
+  const now = params.now ?? Date.now;
+  const verified = [];
+  const rejected = [];
+  const legacy = [];
+  let valueReceived = 0n;
+  const watermarks = /* @__PURE__ */ new Map();
+  const reject = (claim, code, message) => {
+    rejected.push({ claim, code, message });
+  };
+  for (const claim of params.claims) {
+    if (!hasSettlementMetadata(claim)) {
+      legacy.push(claim);
+      continue;
+    }
+    const chain = claim.pair.to.chain;
+    if (chain !== params.expectedChain) {
+      reject(
+        claim,
+        "CHAIN_MISMATCH",
+        `claim settles on "${chain}", session expected "${params.expectedChain}"`
+      );
+      continue;
+    }
+    if (!sameAddress(chain, claim.recipient, params.chainRecipient)) {
+      reject(
+        claim,
+        "RECIPIENT_MISMATCH",
+        `claim recipient "${claim.recipient}" is not the session chainRecipient "${params.chainRecipient}"`
+      );
+      continue;
+    }
+    if (params.expectedSignerAddress !== void 0 && !sameAddress(chain, claim.swapSignerAddress, params.expectedSignerAddress)) {
+      reject(
+        claim,
+        "SWAP_SIGNER_MISMATCH",
+        `claim swapSignerAddress "${claim.swapSignerAddress}" does not match the maker's advertised signer "${params.expectedSignerAddress}"`
+      );
+      continue;
+    }
+    const expectedSigner = params.expectedSignerAddress ?? claim.swapSignerAddress;
+    const sig = verifyAccumulatedClaim(
+      claim,
+      { address: expectedSigner },
+      params.minaSignerClient
+    );
+    if (!sig.valid) {
+      reject(claim, signatureRejectionCode(sig.reason), sig.reason);
+      continue;
+    }
+    let nonce;
+    let cumulativeAmount;
+    try {
+      nonce = BigInt(claim.nonce);
+      cumulativeAmount = BigInt(claim.cumulativeAmount);
+    } catch {
+      reject(
+        claim,
+        "MALFORMED_METADATA",
+        `nonce "${claim.nonce}" / cumulativeAmount "${claim.cumulativeAmount}" are not decimal integers`
+      );
+      continue;
+    }
+    const wmKey = `${chain}|${claim.channelId}`;
+    const watermark = watermarks.get(wmKey) ?? params.store.load(chain, claim.channelId);
+    if (watermark) {
+      if (!sameAddress(chain, watermark.swapSignerAddress, expectedSigner)) {
+        reject(
+          claim,
+          "SWAP_SIGNER_MISMATCH",
+          `channel ${claim.channelId} watermark was signed by "${watermark.swapSignerAddress}"; a claim signed by "${expectedSigner}" may not rotate it`
+        );
+        continue;
+      }
+      if (nonce <= watermark.nonce) {
+        reject(
+          claim,
+          "NON_MONOTONIC_NONCE",
+          `nonce ${nonce} does not advance the persisted watermark nonce ${watermark.nonce} for channel ${claim.channelId}`
+        );
+        continue;
+      }
+      if (cumulativeAmount <= watermark.cumulativeAmount) {
+        reject(
+          claim,
+          "NON_MONOTONIC_CUMULATIVE",
+          `cumulativeAmount ${cumulativeAmount} does not advance the persisted watermark ${watermark.cumulativeAmount} for channel ${claim.channelId}`
+        );
+        continue;
+      }
+    }
+    const advance = cumulativeAmount - (watermark?.cumulativeAmount ?? 0n);
+    if (advance < claim.targetAmount) {
+      reject(
+        claim,
+        "CUMULATIVE_SHORTFALL",
+        `cumulative advance ${advance} is less than the packet's targetAmount ${claim.targetAmount} for channel ${claim.channelId}`
+      );
+      continue;
+    }
+    const entry = {
+      chain,
+      channelId: claim.channelId,
+      nonce,
+      cumulativeAmount,
+      recipient: claim.recipient,
+      swapSignerAddress: expectedSigner,
+      claimBytes: claim.claimBytes,
+      ...claim.claimId !== void 0 ? { claimId: claim.claimId } : {},
+      pair: claim.pair,
+      receivedAt: claim.receivedAt,
+      updatedAt: now(),
+      // Settlement bookkeeping survives watermark advances.
+      ...watermark?.settledAt !== void 0 ? { settledAt: watermark.settledAt } : {},
+      ...watermark?.settledNonce !== void 0 ? { settledNonce: watermark.settledNonce } : {},
+      ...watermark?.settleTxHash !== void 0 ? { settleTxHash: watermark.settleTxHash } : {}
+    };
+    params.store.save(entry);
+    watermarks.set(wmKey, entry);
+    verified.push({ claim, watermarkAdvance: advance });
+    valueReceived += advance;
+  }
+  return { verified, rejected, legacy, valueReceived };
+}
+
 // src/faucet.ts
 function defaultFaucetTimeout(chain) {
   return chain === "mina" ? 12e4 : 3e4;
@@ -6854,7 +7288,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 +7315,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 +7338,7 @@ function encryptMnemonic2(mnemonic, password) {
       version: 1
     };
   } finally {
-    key.fill(0);
+    key2.fill(0);
   }
 }
 function decryptMnemonic2(encrypted, password) {
@@ -6919,14 +7353,14 @@ function decryptMnemonic2(encrypted, password) {
   const iv = Buffer.from(encrypted.iv, "base64");
   const ciphertext = Buffer.from(encrypted.ciphertext, "base64");
   const tag = Buffer.from(encrypted.tag, "base64");
-  const key = scryptSync(password, salt, SCRYPT_KEY_LEN, {
+  const key2 = scryptSync(password, salt, SCRYPT_KEY_LEN, {
     N: SCRYPT_N,
     r: SCRYPT_R,
     p: SCRYPT_P,
     maxmem: SCRYPT_MAXMEM
   });
   try {
-    const decipher = createDecipheriv("aes-256-gcm", key, iv, {
+    const decipher = createDecipheriv("aes-256-gcm", key2, iv, {
       authTagLength: AUTH_TAG_LEN
     });
     decipher.setAuthTag(tag);
@@ -6942,7 +7376,7 @@ function decryptMnemonic2(encrypted, password) {
       );
     }
   } finally {
-    key.fill(0);
+    key2.fill(0);
   }
 }
 function generateKeystore(path, password) {
@@ -6965,7 +7399,7 @@ function importKeystore(path, mnemonic, password) {
 }
 function loadKeystore(path, password) {
   assertNode();
-  const raw = readFileSync2(path, "utf8");
+  const raw = readFileSync3(path, "utf8");
   let parsed;
   try {
     parsed = JSON.parse(raw);
@@ -6976,7 +7410,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,6 +7432,8 @@ export {
   ILP_CLAIM_HEADER,
   ILP_CLAIM_WRAPPED_HEADER,
   ILP_PEER_ID_HEADER,
+  InMemoryReceivedClaimStore,
+  JsonFileReceivedClaimStore,
   KeyManager,
   KindRegistry,
   MIME_A2UI,
@@ -7021,8 +7457,10 @@ export {
   buildRendererEventTemplate,
   buildSettlementInfo,
   buildStoreWriteEnvelope,
+  buildSwapSettlements,
   buildUiCoordinate,
   classifyIntent,
+  decodeEvmSettlementTx,
   decryptMnemonic2 as decryptMnemonic,
   defaultFaucetTimeout,
   deriveFromNsec,
@@ -7030,6 +7468,7 @@ export {
   deriveNostrKeyFromMnemonic,
   deterministicGenerator,
   encryptMnemonic2 as encryptMnemonic,
+  entryToAccumulatedClaim,
   extractArweaveTxId,
   extractUiResource,
   fulfillmentMatchesCondition,
@@ -7040,8 +7479,10 @@ export {
   getNetworkStatus,
   getUiCoordinate,
   guardedRenderDispatch,
+  hasSettlementMetadata,
   httpEndpointToBtpUrl,
   importKeystore,
+  ingestReceivedClaims,
   isInsufficientGasError,
   isPrfSupported,
   isTrustDowngrade,
@@ -7049,6 +7490,7 @@ export {
   loadKeystore,
   mintExecutionCondition,
   parseBackupPayload,
+  parseEvmChainId2 as parseEvmChainId,
   parseFulfillHttp,
   parseFulfillHttpBytes,
   parseHttpResponse,
@@ -7074,6 +7516,7 @@ export {
   selectIlpTransport,
   selectLatestAddressable,
   serializeHttpRequest,
+  submitEvmSettlement,
   validateConfig,
   validateMnemonic,
   verifyRendererTrust,