@toon-protocol/client 0.15.0 → 0.17.0

package/dist/index.js

@@ -894,9 +894,13 @@ function deserializeIlpPacket(buf) {
 }
 function deserializeIlpFulfill(buf) {
   let offset = 1;
+  if (buf.length < offset + 32) {
+    throw new Error("Buffer underflow reading FULFILL fulfillment");
+  }
+  const fulfillment = buf.slice(offset, offset + 32);
   offset += 32;
   const { value: data } = decodeVarOctetString(buf, offset);
-  return { type: ILPPacketType.FULFILL, data };
+  return { type: ILPPacketType.FULFILL, fulfillment, data };
 }
 function deserializeIlpReject(buf) {
   let offset = 1;
@@ -1207,8 +1211,10 @@ var IsomorphicBtpClient = class {
             this.pendingRequests.delete(id);
             if (json["type"] === "FULFILL") {
               const responseData = json["data"] ? this.base64ToUint8Array(json["data"]) : new Uint8Array(0);
+              const fulfillment = json["fulfillment"] ? this.base64ToUint8Array(json["fulfillment"]) : new Uint8Array(32);
               pending.resolve({
                 type: ILPPacketType.FULFILL,
+                fulfillment,
                 data: responseData
               });
             } else {
@@ -1269,6 +1275,70 @@ var IsomorphicBtpClient = class {
   }
 };
 
+// src/utils/condition.ts
+import { sha256 } from "@noble/hashes/sha2.js";
+import { randomBytes } from "@noble/hashes/utils.js";
+var CONDITION_LENGTH = 32;
+function mintExecutionCondition() {
+  const preimage = randomBytes(CONDITION_LENGTH);
+  return { preimage, condition: sha256(preimage) };
+}
+function isZeroCondition(condition) {
+  if (condition === void 0) return true;
+  for (const byte of condition) {
+    if (byte !== 0) return false;
+  }
+  return true;
+}
+function assertValidCondition(condition) {
+  if (condition.length !== CONDITION_LENGTH) {
+    throw new Error(
+      `executionCondition must be exactly ${CONDITION_LENGTH} bytes, got ${condition.length}`
+    );
+  }
+}
+function fulfillmentMatchesCondition(fulfillment, condition) {
+  if (fulfillment === void 0 || fulfillment.length !== CONDITION_LENGTH) {
+    return false;
+  }
+  const digest = sha256(fulfillment);
+  for (let i = 0; i < CONDITION_LENGTH; i++) {
+    if (digest[i] !== condition[i]) return false;
+  }
+  return true;
+}
+
+// src/adapters/ilp-send.ts
+var FULFILLMENT_MISMATCH_CODE = "F99";
+var FULFILLMENT_MISMATCH_MESSAGE = "FULFILL fulfillment does not match execution condition (sha256(fulfillment) != executionCondition) \u2014 packet counted failed";
+function mapIlpResponse(packet, sentCondition) {
+  if (packet.type === ILPPacketType.FULFILL) {
+    const dataField = packet.data.length > 0 ? { data: toBase64(packet.data) } : {};
+    if (sentCondition === void 0 || isZeroCondition(sentCondition)) {
+      return { accepted: true, ...dataField };
+    }
+    if (!fulfillmentMatchesCondition(packet.fulfillment, sentCondition)) {
+      return {
+        accepted: false,
+        code: FULFILLMENT_MISMATCH_CODE,
+        message: FULFILLMENT_MISMATCH_MESSAGE,
+        ...dataField
+      };
+    }
+    return {
+      accepted: true,
+      fulfillment: toBase64(packet.fulfillment),
+      ...dataField
+    };
+  }
+  return {
+    accepted: false,
+    code: packet.code,
+    message: packet.message,
+    ...packet.data.length > 0 ? { data: toBase64(packet.data) } : {}
+  };
+}
+
 // src/adapters/BtpRuntimeClient.ts
 function isConnectionError(error) {
   const msg = error.message.toLowerCase();
@@ -1324,6 +1394,12 @@ var BtpRuntimeClient = class {
   /**
    * Sends an ILP packet via BTP with auto-reconnect on connection errors.
    * Satisfies IlpClient interface.
+   *
+   * `params` may carry a sender-chosen `executionCondition` and an explicit
+   * `expiresAt` (toon-client#350); omitting both is the legacy zero-condition
+   * path, unchanged. With a non-zero condition the FULFILL preimage is
+   * verified (`sha256(fulfillment) == condition`) and a mismatch is surfaced
+   * as a failed result — see `mapIlpResponse`.
    */
   async sendIlpPacket(params) {
     return withRetry(() => this._sendIlpPacketOnce(params), {
@@ -1339,6 +1415,9 @@ var BtpRuntimeClient = class {
   /**
    * Sends a balance proof claim via BTP protocol data, then sends an ILP packet.
    * Auto-reconnects on connection errors.
+   *
+   * Sender-chosen `executionCondition` / explicit `expiresAt` semantics are
+   * identical to {@link sendIlpPacket}.
    */
   async sendIlpPacketWithClaim(params, claim) {
     return withRetry(() => this._sendIlpPacketWithClaimOnce(params, claim), {
@@ -1381,6 +1460,30 @@ var BtpRuntimeClient = class {
       encodeUtf8(JSON.stringify(claim))
     );
   }
+  /**
+   * Build the ILP PREPARE for a send, applying the sender-chosen condition /
+   * explicit expiry when provided (toon-client#350) and validating that a
+   * non-zero condition is exactly 32 bytes (the OER serializer would
+   * otherwise silently zero-fill it, downgrading the packet to the legacy
+   * unverified class).
+   */
+  buildPrepare(params) {
+    const condition = params.executionCondition;
+    if (condition !== void 0 && !isZeroCondition(condition)) {
+      assertValidCondition(condition);
+    }
+    return {
+      prepare: {
+        type: 12,
+        amount: BigInt(params.amount),
+        destination: params.destination,
+        executionCondition: condition ?? new Uint8Array(32),
+        expiresAt: params.expiresAt ?? new Date(Date.now() + (params.timeout ?? 3e4)),
+        data: fromBase64(params.data)
+      },
+      condition
+    };
+  }
   /**
    * Single-attempt ILP packet send. Reconnects if not connected.
    */
@@ -1388,26 +1491,9 @@ var BtpRuntimeClient = class {
     if (!this._isConnected) {
       await this.reconnect();
     }
-    const response = await this.btpClient.sendPacket({
-      type: 12,
-      amount: BigInt(params.amount),
-      destination: params.destination,
-      executionCondition: new Uint8Array(32),
-      expiresAt: new Date(Date.now() + (params.timeout ?? 3e4)),
-      data: fromBase64(params.data)
-    });
-    if (response.type === ILPPacketType.FULFILL) {
-      return {
-        accepted: true,
-        data: response.data.length > 0 ? toBase64(response.data) : void 0
-      };
-    }
-    return {
-      accepted: false,
-      code: response.code,
-      message: response.message,
-      data: response.data.length > 0 ? toBase64(response.data) : void 0
-    };
+    const { prepare, condition } = this.buildPrepare(params);
+    const response = await this.btpClient.sendPacket(prepare);
+    return mapIlpResponse(response, condition);
   }
   /**
    * Single-attempt claim + ILP packet send. Reconnects if not connected.
@@ -1426,29 +1512,9 @@ var BtpRuntimeClient = class {
         data: encodeUtf8(JSON.stringify(claim))
       }
     ];
-    const response = await this.btpClient.sendPacket(
-      {
-        type: 12,
-        amount: BigInt(params.amount),
-        destination: params.destination,
-        executionCondition: new Uint8Array(32),
-        expiresAt: new Date(Date.now() + (params.timeout ?? 3e4)),
-        data: fromBase64(params.data)
-      },
-      protocolData
-    );
-    if (response.type === ILPPacketType.FULFILL) {
-      return {
-        accepted: true,
-        data: response.data.length > 0 ? toBase64(response.data) : void 0
-      };
-    }
-    return {
-      accepted: false,
-      code: response.code,
-      message: response.message,
-      data: response.data.length > 0 ? toBase64(response.data) : void 0
-    };
+    const { prepare, condition } = this.buildPrepare(params);
+    const response = await this.btpClient.sendPacket(prepare, protocolData);
+    return mapIlpResponse(response, condition);
   }
 };
 
@@ -1480,6 +1546,12 @@ var HttpIlpClient = class {
    * Send an ILP PREPARE via `POST /ilp` WITHOUT a claim. The connector accepts
    * this only on free/zero-amount routes; paid writes must use
    * {@link sendIlpPacketWithClaim}. Satisfies the IlpClient interface.
+   *
+   * `params` may carry a sender-chosen `executionCondition` and an explicit
+   * `expiresAt` (toon-client#350); omitting both is the legacy zero-condition
+   * path, unchanged. With a non-zero condition the FULFILL preimage is
+   * verified (`sha256(fulfillment) == condition`) and a mismatch is surfaced
+   * as a failed result — see {@link mapIlpResponse}.
    */
   async sendIlpPacket(params) {
     return withRetry(() => this.postPrepare(params), {
@@ -1494,6 +1566,9 @@ var HttpIlpClient = class {
    * as the `ILP-Payment-Channel-Claim` header. `claim` is the SAME JSON object
    * the BTP path attaches as the `payment-channel-claim` protocolData entry —
    * we base64(JSON.stringify(claim)) it, byte-for-byte identical to BTP.
+   *
+   * Sender-chosen `executionCondition` / explicit `expiresAt` semantics are
+   * identical to {@link sendIlpPacket}.
    */
   async sendIlpPacketWithClaim(params, claim) {
     return withRetry(() => this.postPrepare(params, claim), {
@@ -1546,12 +1621,16 @@ var HttpIlpClient = class {
    */
   async postPrepare(params, claim) {
     const requestTimeout = params.timeout ?? this.timeout;
+    const condition = params.executionCondition;
+    if (condition !== void 0 && !isZeroCondition(condition)) {
+      assertValidCondition(condition);
+    }
     const prepare = serializeIlpPrepare({
       type: ILPPacketType.PREPARE,
       amount: BigInt(params.amount),
       destination: params.destination,
-      executionCondition: new Uint8Array(32),
-      expiresAt: new Date(Date.now() + requestTimeout),
+      executionCondition: condition ?? new Uint8Array(32),
+      expiresAt: params.expiresAt ?? new Date(Date.now() + requestTimeout),
       data: fromBase64(params.data)
     });
     const headers = {
@@ -1574,7 +1653,7 @@ var HttpIlpClient = class {
         signal: controller.signal
       });
       clearTimeout(timeoutId);
-      return await this.mapResponse(response);
+      return await this.mapResponse(response, condition);
     } catch (error) {
       clearTimeout(timeoutId);
       throw this.mapTransportError(error, requestTimeout);
@@ -1584,26 +1663,18 @@ var HttpIlpClient = class {
    * Map a `200 OK` body (OER FULFILL/REJECT) to an IlpSendResult; map a non-2xx
    * to a transport error. Per the wire contract, ILP-level rejects arrive as a
    * 200 + REJECT body — only HTTP non-2xx means a transport-layer failure.
+   *
+   * When `sentCondition` is non-zero the FULFILL preimage is verified against
+   * it; a mismatch yields `accepted: false` (shared `mapIlpResponse` logic,
+   * identical to the BTP path).
    */
-  async mapResponse(response) {
+  async mapResponse(response, sentCondition) {
     if (response.ok) {
       const buf = new Uint8Array(await response.arrayBuffer());
       if (buf.length === 0) {
         throw new ConnectorError("Empty 200 body from /ilp (expected OER ILP response)");
       }
-      const ilp = deserializeIlpPacket(buf);
-      if (ilp.type === ILPPacketType.FULFILL) {
-        return {
-          accepted: true,
-          data: ilp.data.length > 0 ? toBase64(ilp.data) : void 0
-        };
-      }
-      return {
-        accepted: false,
-        code: ilp.code,
-        message: ilp.message,
-        data: ilp.data.length > 0 ? toBase64(ilp.data) : void 0
-      };
+      return mapIlpResponse(deserializeIlpPacket(buf), sentCondition);
     }
     const body = await response.text().catch(() => "");
     const detail = body ? `: ${body}` : "";
@@ -1692,7 +1763,7 @@ import { base58Encode as base58Encode2 } from "@toon-protocol/core";
 
 // src/channel/solana-payment-channel.ts
 import { ed25519 } from "@noble/curves/ed25519.js";
-import { sha256 } from "@noble/hashes/sha2.js";
+import { sha256 as sha2562 } from "@noble/hashes/sha2.js";
 import { base58Encode, base58Decode } from "@toon-protocol/core";
 var TOKEN_PROGRAM_ID = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
 var SYSTEM_PROGRAM_ID = "11111111111111111111111111111111";
@@ -1781,7 +1852,7 @@ function findProgramAddress(seeds, programId) {
     input.set(programId, offset);
     offset += programId.length;
     input.set(PDA_MARKER, offset);
-    const hash = sha256(input);
+    const hash = sha2562(input);
     if (!isOnCurve(hash)) return { pda: hash, bump };
   }
   throw new Error("Could not find a viable PDA bump seed");
@@ -3234,7 +3305,7 @@ var SolanaSigner = class {
 
 // src/signing/mina-signer.ts
 import { hexToMinaBase58PrivateKey as hexToMinaBase58PrivateKey3 } from "@toon-protocol/core";
-import { sha256 as sha2562 } from "@noble/hashes/sha2.js";
+import { sha256 as sha2563 } from "@noble/hashes/sha2.js";
 import { bytesToHex } from "@noble/hashes/utils.js";
 
 // src/channel/mina-payment-channel.ts
@@ -3365,7 +3436,7 @@ var DEFAULT_MINA_TOKEN_ID = "MINA";
 var MINA_CLAIM_NETWORK = "devnet";
 function deriveMinaSalt(zkAppAddress, nonce) {
   const digestHex = bytesToHex(
-    sha2562(new TextEncoder().encode(`mina-pc-salt:${zkAppAddress}:${nonce}`))
+    sha2563(new TextEncoder().encode(`mina-pc-salt:${zkAppAddress}:${nonce}`))
   );
   const salt = BigInt("0x" + digestHex.slice(0, 60));
   return salt === 0n ? 1n : salt;
@@ -3957,6 +4028,38 @@ async function readEvmTokenBalance(opts) {
   if (decimals !== void 0) out.assetScale = Number(decimals);
   return out;
 }
+async function readEvmNativeBalance(opts) {
+  const chainId = parseEvmChainId(opts.chainKey);
+  const client = createPublicClient2({
+    transport: http2(opts.rpcUrl),
+    chain: defineChain2({
+      id: chainId,
+      name: opts.chainKey,
+      nativeCurrency: { name: "ETH", symbol: "ETH", decimals: 18 },
+      rpcUrls: { default: { http: [opts.rpcUrl] } }
+    })
+  });
+  const wei = await client.getBalance({ address: opts.owner });
+  return { symbol: "ETH", amount: wei.toString(), decimals: 18 };
+}
+async function readSolanaNativeBalance(opts) {
+  const fetchImpl = opts.fetchImpl ?? fetch;
+  const res = await fetchImpl(opts.rpcUrl, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({
+      jsonrpc: "2.0",
+      id: 1,
+      method: "getBalance",
+      params: [opts.owner, { commitment: "confirmed" }]
+    })
+  });
+  if (!res.ok) throw new Error(`Solana RPC request failed: HTTP ${res.status}`);
+  const json = await res.json();
+  if (json.error) throw new Error(`Solana RPC error: ${json.error.message ?? "unknown"}`);
+  const lamports = BigInt(json.result?.value ?? 0);
+  return { symbol: "SOL", amount: lamports.toString(), decimals: 9 };
+}
 async function readSolanaTokenBalance(opts) {
   const fetchImpl = opts.fetchImpl ?? fetch;
   const res = await fetchImpl(opts.rpcUrl, {
@@ -4004,6 +4107,95 @@ async function readMinaBalance(opts) {
     assetScale: 9
   };
 }
+var errText = (e) => e instanceof Error ? e.message : String(e);
+function foldNative(out, settled, errors) {
+  if (settled.status === "fulfilled") out.native = settled.value;
+  else errors.push(errText(settled.reason));
+}
+function foldToken(out, settled, tokenAddress, errors) {
+  if (settled.status === "rejected") {
+    errors.push(errText(settled.reason));
+    return;
+  }
+  const bal = settled.value;
+  if (!bal) return;
+  out.tokens.push({
+    symbol: bal.asset,
+    amount: bal.amount,
+    decimals: bal.assetScale,
+    ...tokenAddress ? { address: tokenAddress } : {}
+  });
+}
+function finalizeChain(out, errors) {
+  if (errors.length > 0) out.error = errors[0];
+  if (out.native === void 0 && out.tokens.length === 0) out.unreadable = true;
+}
+async function readWalletBalances(sources) {
+  const { fetchImpl } = sources;
+  const tasks = [];
+  if (sources.evm) {
+    const { chainKey, rpcUrl, owner, tokenAddress } = sources.evm;
+    tasks.push(
+      (async () => {
+        const out = { chain: "evm", chainKey, address: owner, tokens: [] };
+        const errors = [];
+        const [nativeR, tokenR] = await Promise.allSettled([
+          readEvmNativeBalance({ rpcUrl, chainKey, owner }),
+          tokenAddress ? readEvmTokenBalance({ rpcUrl, chainKey, tokenAddress, owner }) : Promise.resolve(void 0)
+        ]);
+        foldNative(out, nativeR, errors);
+        foldToken(out, tokenR, tokenAddress, errors);
+        finalizeChain(out, errors);
+        return out;
+      })()
+    );
+  }
+  if (sources.solana) {
+    const { chainKey = "solana", rpcUrl, owner, tokenMint } = sources.solana;
+    tasks.push(
+      (async () => {
+        const out = { chain: "solana", chainKey, address: owner, tokens: [] };
+        const errors = [];
+        const [nativeR, tokenR] = await Promise.allSettled([
+          readSolanaNativeBalance({ rpcUrl, owner, fetchImpl }),
+          tokenMint ? readSolanaTokenBalance({ rpcUrl, mint: tokenMint, owner, fetchImpl }) : Promise.resolve(void 0)
+        ]);
+        foldNative(out, nativeR, errors);
+        if (tokenR.status === "fulfilled" && tokenR.value && tokenR.value.asset === void 0) {
+          tokenR.value.asset = "USDC";
+        }
+        foldToken(out, tokenR, tokenMint, errors);
+        finalizeChain(out, errors);
+        return out;
+      })()
+    );
+  }
+  if (sources.mina) {
+    const { chainKey = "mina", graphqlUrl, owner } = sources.mina;
+    tasks.push(
+      (async () => {
+        const out = { chain: "mina", chainKey, address: owner, tokens: [] };
+        const errors = [];
+        const nativeR = await Promise.allSettled([readMinaBalance({ graphqlUrl, owner, fetchImpl })]);
+        foldNative(
+          out,
+          nativeR[0].status === "fulfilled" ? {
+            status: "fulfilled",
+            value: {
+              symbol: nativeR[0].value.asset,
+              amount: nativeR[0].value.amount,
+              decimals: nativeR[0].value.assetScale
+            }
+          } : nativeR[0],
+          errors
+        );
+        finalizeChain(out, errors);
+        return out;
+      })()
+    );
+  }
+  return Promise.all(tasks);
+}
 
 // src/blob-storage.ts
 import { buildBlobStorageRequest } from "@toon-protocol/core";
@@ -4776,6 +4968,14 @@ var ToonClient = class {
    *       matching `destination`,
    *   (c) neither -> throw MISSING_CLAIM.
    *
+   * A caller may supply a sender-chosen 32-byte `executionCondition`
+   * (`C = sha256(P)`, one fresh preimage per packet — toon-client#350,
+   * rolling-swap spec §3 R1/R2) and an explicit `expiresAt` (R7). Both are
+   * set on the wire by either transport (HTTP `POST /ilp` and BTP), and on
+   * FULFILL the transport verifies `sha256(fulfillment) == condition` —
+   * a mismatch comes back as `accepted: false` (code F99), never a silent
+   * accept. Omitting them keeps today's zero-condition legacy packet.
+   *
    * @throws {ToonClientError} INVALID_STATE / NO_ILP_TRANSPORT / MISSING_CLAIM
    */
   async sendSwapPacket(params) {
@@ -4796,7 +4996,9 @@ var ToonClient = class {
         destination: params.destination,
         amount: String(params.amount),
         data: toBase64(params.toonData),
-        timeout: params.timeout ?? 3e4
+        timeout: params.timeout ?? 3e4,
+        ...params.executionCondition ? { executionCondition: params.executionCondition } : {},
+        ...params.expiresAt ? { expiresAt: params.expiresAt } : {}
       },
       claimMessage
     );
@@ -5154,6 +5356,74 @@ var ToonClient = class {
     }
     return out;
   }
+  /**
+   * The FULL multi-chain wallet view (#299): for every chain the identity is
+   * configured for, the native coin (ETH / SOL / MINA) AND every configured
+   * token (USDC), grouped per chain with the identity's address on that chain.
+   * A superset of {@link getBalances} — which stays scoped to the channel's
+   * settlement token — kept as a separate reader so channel-settlement callers
+   * are unaffected.
+   *
+   * FREE: read-only RPC, no signing, no payment. Works on an UNSTARTED client:
+   * the Solana/Mina addresses (which the signers only register during
+   * `start()`) are derived on demand from the retained mnemonic — the SAME keys
+   * `start()` would register and that `rig fund` prints — so all configured
+   * chains appear even before a start. Best-effort per chain: an unreachable
+   * RPC yields `{ unreadable: true }` for that chain, never failing the others.
+   */
+  async getWalletBalances() {
+    const sources = {};
+    let derived;
+    let derivedTried = false;
+    const ensureDerived = async () => {
+      if (derivedTried) return derived;
+      derivedTried = true;
+      if (this.config.mnemonic) {
+        derived = await deriveFullIdentity(
+          this.config.mnemonic,
+          this.config.mnemonicAccountIndex ?? 0
+        );
+      }
+      return derived;
+    };
+    const evmAddress = this.getEvmAddress();
+    const rpcUrls = this.config.chainRpcUrls;
+    const tokens = this.config.preferredTokens;
+    if (evmAddress && rpcUrls) {
+      const usableEvm = (c) => c.startsWith("evm") && Boolean(rpcUrls[c]);
+      const settlementKeys = Object.keys(this.config.settlementAddresses ?? {});
+      const chainKeys = this.config.supportedChains ?? Object.keys(rpcUrls);
+      const chainKey = settlementKeys.find(usableEvm) ?? chainKeys.find(usableEvm);
+      if (chainKey && rpcUrls[chainKey]) {
+        sources.evm = {
+          chainKey,
+          rpcUrl: rpcUrls[chainKey],
+          owner: evmAddress,
+          ...tokens?.[chainKey] ? { tokenAddress: tokens[chainKey] } : {}
+        };
+      }
+    }
+    const sol = this.config.solanaChannel;
+    if (sol?.rpcUrl) {
+      const solAddress = this.getSolanaAddress() ?? (await ensureDerived())?.solana.publicKey;
+      if (solAddress) {
+        sources.solana = {
+          chainKey: "solana",
+          rpcUrl: sol.rpcUrl,
+          owner: solAddress,
+          ...sol.tokenMint ? { tokenMint: sol.tokenMint } : {}
+        };
+      }
+    }
+    const mina = this.config.minaChannel;
+    if (mina?.graphqlUrl) {
+      const minaAddress = this.getMinaAddress() ?? (await ensureDerived())?.mina.publicKey;
+      if (minaAddress) {
+        sources.mina = { chainKey: "mina", graphqlUrl: mina.graphqlUrl, owner: minaAddress };
+      }
+    }
+    return readWalletBalances(sources);
+  }
   /**
    * Resolves an ILP destination address to a peer ID.
    * Convention: destination "g.toon.peer1" → peerId "peer1" (last segment).
@@ -6582,7 +6852,7 @@ import {
   scryptSync,
   createCipheriv,
   createDecipheriv,
-  randomBytes
+  randomBytes as randomBytes2
 } from "crypto";
 import { writeFileSync as writeFileSync2, readFileSync as readFileSync2 } from "fs";
 var SCRYPT_N = 2 ** 17;
@@ -6609,8 +6879,8 @@ function encryptMnemonic2(mnemonic, password) {
   if (typeof password !== "string" || password.length === 0) {
     throw new Error("encryptMnemonic: password must be a non-empty string");
   }
-  const salt = randomBytes(SALT_LEN);
-  const iv = randomBytes(IV_LEN);
+  const salt = randomBytes2(SALT_LEN);
+  const iv = randomBytes2(IV_LEN);
   const key = scryptSync(password, salt, SCRYPT_KEY_LEN, {
     N: SCRYPT_N,
     r: SCRYPT_R,
@@ -6713,10 +6983,13 @@ function writeKeystoreFile(path, keystore) {
 }
 export {
   BtpRuntimeClient,
+  CONDITION_LENGTH,
   ChannelFundingError,
   ChannelManager,
   ConnectorError,
   EvmSigner,
+  FULFILLMENT_MISMATCH_CODE,
+  FULFILLMENT_MISMATCH_MESSAGE,
   GenerativeFallbackRenderer,
   Http402Client,
   HttpConnectorAdmin,
@@ -6741,6 +7014,7 @@ export {
   ValidationError,
   applyDefaults,
   applyNetworkPresets,
+  assertValidCondition,
   buildBackupEvent,
   buildBackupFilter,
   buildConsentRequest,
@@ -6758,6 +7032,7 @@ export {
   encryptMnemonic2 as encryptMnemonic,
   extractArweaveTxId,
   extractUiResource,
+  fulfillmentMatchesCondition,
   fundWallet,
   generateKeystore,
   generateMnemonic,
@@ -6770,7 +7045,9 @@ export {
   isInsufficientGasError,
   isPrfSupported,
   isTrustDowngrade,
+  isZeroCondition,
   loadKeystore,
+  mintExecutionCondition,
   parseBackupPayload,
   parseFulfillHttp,
   parseFulfillHttpBytes,
@@ -6781,7 +7058,13 @@ export {
   proxyIlpEndpoint,
   publishBackCoordinate,
   readDiscoveredIlpPeer,
+  readEvmNativeBalance,
+  readEvmTokenBalance,
+  readMinaBalance,
   readMinaDepositTotal,
+  readSolanaNativeBalance,
+  readSolanaTokenBalance,
+  readWalletBalances,
   renderDeterministicHtml,
   renderDispatch,
   requestBlobStorage,