@toon-protocol/client 0.9.1 → 0.10.0

package/dist/index.js

@@ -1,10 +1,18 @@
-import "./chunk-5WRI5ZAA.js";
+import {
+  ANON_ASSETS,
+  ANON_VERSION,
+  selectAnonAsset,
+  startManagedAnonProxy
+} from "./chunk-WHAEQLIW.js";
 
 // src/ToonClient.ts
-import { generateSecretKey as generateSecretKey2, getPublicKey } from "nostr-tools/pure";
+import { generateSecretKey as generateSecretKey3, getPublicKey as getPublicKey2, finalizeEvent } from "nostr-tools/pure";
 
 // src/config.ts
-import { generateSecretKey } from "nostr-tools/pure";
+import { generateSecretKey as generateSecretKey2 } from "nostr-tools/pure";
+import {
+  resolveClientNetwork
+} from "@toon-protocol/core";
 
 // src/errors.ts
 var ToonClientError = class extends Error {
@@ -13,6 +21,7 @@ var ToonClientError = class extends Error {
     this.code = code;
     this.name = "ToonClientError";
   }
+  code;
 };
 var NetworkError = class extends ToonClientError {
   constructor(message, cause) {
@@ -51,7 +60,209 @@ var PeerAlreadyExistsError = class extends ToonClientError {
   }
 };
 
+// src/keys/KeyDerivation.ts
+import { generateSecretKey, getPublicKey } from "nostr-tools/pure";
+import { privateKeyToAccount } from "viem/accounts";
+import { toHex } from "viem";
+import {
+  generateMnemonic as _genMnemonic,
+  validateMnemonic as _validateMnemonic,
+  mnemonicToSeedSync
+} from "@scure/bip39";
+import { wordlist as english } from "@scure/bip39/wordlists/english";
+import { HDKey } from "@scure/bip32";
+import { hexToMinaBase58PrivateKey } from "@toon-protocol/core";
+function generateMnemonic() {
+  return _genMnemonic(english, 128);
+}
+function validateMnemonic(mnemonic) {
+  return _validateMnemonic(mnemonic, english);
+}
+var MAX_BIP32_INDEX = 2147483647;
+function assertValidAccountIndex(accountIndex) {
+  if (!Number.isInteger(accountIndex) || accountIndex < 0 || accountIndex > MAX_BIP32_INDEX) {
+    throw new Error(
+      `Invalid accountIndex: expected a non-negative integer (0 to ${MAX_BIP32_INDEX}), got ${String(accountIndex)}`
+    );
+  }
+}
+function deriveNostrKey(seed, accountIndex = 0) {
+  const master = HDKey.fromMasterSeed(seed);
+  const child = master.derive(`m/44'/1237'/0'/0/${accountIndex}`);
+  if (!child.privateKey) {
+    throw new Error("Failed to derive Nostr private key from seed");
+  }
+  const secretKey = new Uint8Array(child.privateKey);
+  const pubkey = getPublicKey(secretKey);
+  return { secretKey, pubkey };
+}
+function deriveEvmIdentity(secretKey) {
+  const account = privateKeyToAccount(toHex(secretKey));
+  return {
+    privateKey: secretKey,
+    address: account.address
+  };
+}
+async function deriveSolanaKey(seed, accountIndex = 0) {
+  const { hmac } = await import("@noble/hashes/hmac");
+  const { sha512 } = await import("@noble/hashes/sha512");
+  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 chainCode = I.slice(32);
+  const indices = [
+    2147483692,
+    // 44'
+    2147484149,
+    // 501'
+    2147483648 + accountIndex >>> 0,
+    // {accountIndex}'
+    2147483648
+    // 0'
+  ];
+  for (const index of indices) {
+    const data = new Uint8Array(37);
+    data[0] = 0;
+    data.set(key, 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);
+    chainCode = I.slice(32);
+  }
+  const publicKeyBytes = ed255194.getPublicKey(key);
+  const keypair = new Uint8Array(64);
+  keypair.set(key, 0);
+  keypair.set(publicKeyBytes, 32);
+  const publicKey = toBase58(publicKeyBytes);
+  return { secretKey: keypair, publicKey };
+}
+async function deriveMinaKey(seed, accountIndex = 0) {
+  const master = HDKey.fromMasterSeed(seed);
+  const child = master.derive(`m/44'/12586'/${accountIndex}'/0/0`);
+  if (!child.privateKey) {
+    throw new Error("Failed to derive Mina private key from seed");
+  }
+  const keyBytes = new Uint8Array(child.privateKey);
+  keyBytes[0] = (keyBytes[0] ?? 0) & 63;
+  try {
+    const MinaSignerLib = await import("mina-signer");
+    const Client = "default" in MinaSignerLib ? MinaSignerLib.default : MinaSignerLib;
+    const client = new Client({ network: "mainnet" });
+    const hexKey = Array.from(keyBytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+    const minaPrivateKey = hexToMinaBase58PrivateKey(hexKey);
+    const publicKey = client.derivePublicKey(minaPrivateKey);
+    return {
+      // Store the clamped big-endian hex scalar; consumers (e.g. the client's
+      // MinaSigner) re-convert to base58check via hexToMinaBase58PrivateKey.
+      privateKey: hexKey,
+      publicKey
+    };
+  } catch {
+    throw new Error(
+      "mina-signer is required for Mina key derivation. Install it as an optional dependency."
+    );
+  }
+}
+function deriveNostrKeyFromMnemonic(mnemonic, accountIndex = 0) {
+  assertValidAccountIndex(accountIndex);
+  const seed = mnemonicToSeedSync(mnemonic);
+  const result = deriveNostrKey(seed, accountIndex);
+  seed.fill(0);
+  return result;
+}
+async function deriveFullIdentity(mnemonic, accountIndex = 0) {
+  assertValidAccountIndex(accountIndex);
+  const seed = mnemonicToSeedSync(mnemonic);
+  const nostr = deriveNostrKey(seed, accountIndex);
+  const evm = deriveEvmIdentity(nostr.secretKey);
+  let solana;
+  try {
+    solana = await deriveSolanaKey(seed, accountIndex);
+  } catch {
+    solana = { secretKey: new Uint8Array(64), publicKey: "" };
+  }
+  let mina;
+  try {
+    mina = await deriveMinaKey(seed, accountIndex);
+  } catch {
+    mina = { privateKey: "", publicKey: "" };
+  }
+  seed.fill(0);
+  return { nostr, evm, solana, mina };
+}
+function deriveFromNsec(secretKey) {
+  const keyCopy = new Uint8Array(secretKey);
+  const pubkey = getPublicKey(keyCopy);
+  const evm = deriveEvmIdentity(keyCopy);
+  return {
+    nostr: { secretKey: keyCopy, pubkey },
+    evm,
+    solana: { secretKey: new Uint8Array(64), publicKey: "" },
+    mina: { privateKey: "", publicKey: "" }
+  };
+}
+function generateRandomIdentity() {
+  const secretKey = generateSecretKey();
+  return deriveFromNsec(secretKey);
+}
+var BASE58_ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+function toBase58(bytes) {
+  let num = BigInt(0);
+  for (const b of bytes) num = num * 256n + BigInt(b);
+  let result = "";
+  while (num > 0n) {
+    result = BASE58_ALPHABET[Number(num % 58n)] + result;
+    num = num / 58n;
+  }
+  for (const b of bytes) {
+    if (b === 0) result = "1" + result;
+    else break;
+  }
+  return result;
+}
+
 // src/config.ts
+function applyNetworkPresets(config) {
+  const { network } = config;
+  if (!network || network === "custom") return config;
+  const presets = resolveClientNetwork(network);
+  const mergeRecord = (explicit, preset) => ({ ...preset, ...explicit });
+  const supportedChains = config.supportedChains ? Array.from(
+    /* @__PURE__ */ new Set([...presets.supportedChains, ...config.supportedChains])
+  ) : presets.supportedChains;
+  return {
+    ...config,
+    supportedChains,
+    chainRpcUrls: mergeRecord(config.chainRpcUrls, presets.chainRpcUrls),
+    preferredTokens: mergeRecord(
+      config.preferredTokens,
+      presets.preferredTokens
+    ),
+    tokenNetworks: mergeRecord(config.tokenNetworks, presets.tokenNetworks),
+    // settlementAddresses are identity-derived (per-client), so they have no
+    // preset; pass any explicit value through unchanged.
+    ...config.settlementAddresses && {
+      settlementAddresses: config.settlementAddresses
+    },
+    // Channel params: preset fills the deployed programId/zkApp + URLs unless
+    // the caller supplied their own (explicit object wins wholesale).
+    ...presets.solanaChannel && {
+      solanaChannel: config.solanaChannel ?? presets.solanaChannel
+    },
+    ...presets.minaChannel && {
+      minaChannel: config.minaChannel ?? presets.minaChannel
+    }
+  };
+}
+function getNetworkStatus(config) {
+  const { network } = config;
+  if (!network || network === "custom") return void 0;
+  return resolveClientNetwork(network).status;
+}
 function validateConfig(config) {
   if (config.connector !== void 0) {
     throw new ValidationError(
@@ -80,6 +291,24 @@ function validateConfig(config) {
       );
     }
   }
+  if (config.mnemonic !== void 0) {
+    if (config.secretKey !== void 0) {
+      throw new ValidationError(
+        "Provide either `mnemonic` or `secretKey`, not both \u2014 the mnemonic derives the Nostr key, so a separate secretKey would yield an inconsistent cross-chain identity. (An `evmPrivateKey` override is allowed.)"
+      );
+    }
+    if (typeof config.mnemonic !== "string" || !validateMnemonic(config.mnemonic)) {
+      throw new ValidationError("mnemonic must be a valid BIP-39 phrase");
+    }
+  }
+  if (config.mnemonicAccountIndex !== void 0) {
+    const idx = config.mnemonicAccountIndex;
+    if (!Number.isInteger(idx) || idx < 0 || idx > 2147483647) {
+      throw new ValidationError(
+        "mnemonicAccountIndex must be a non-negative integer (0 to 2147483647)"
+      );
+    }
+  }
   if (!config.ilpInfo?.ilpAddress) {
     throw new ValidationError("ilpInfo.ilpAddress is required");
   }
@@ -117,6 +346,25 @@ function validateConfig(config) {
       );
     }
   }
+  if (config.transport) {
+    if (config.transport.type === "socks5") {
+      if (!config.transport.socksProxy?.startsWith("socks5h://")) {
+        throw new ValidationError(
+          'transport.socksProxy must use socks5h:// scheme to prevent DNS leaks. The "h" suffix ensures .anyone hostnames are resolved by the proxy, not locally.'
+        );
+      }
+    } else if (config.transport.type === "gateway") {
+      if (!config.transport.gatewayUrl) {
+        throw new ValidationError(
+          "transport.gatewayUrl is required for gateway transport"
+        );
+      }
+    } else if (config.transport.type !== "direct") {
+      throw new ValidationError(
+        `Unknown transport type: "${config.transport.type}"`
+      );
+    }
+  }
   if (config.chainRpcUrls && config.supportedChains) {
     for (const chain of Object.keys(config.chainRpcUrls)) {
       if (!config.supportedChains.includes(chain)) {
@@ -127,8 +375,12 @@ function validateConfig(config) {
     }
   }
 }
-function applyDefaults(config) {
-  const secretKey = config.secretKey ?? generateSecretKey();
+function applyDefaults(rawConfig) {
+  const config = applyNetworkPresets(rawConfig);
+  const secretKey = config.secretKey ?? (config.mnemonic ? deriveNostrKeyFromMnemonic(
+    config.mnemonic,
+    config.mnemonicAccountIndex ?? 0
+  ).secretKey : generateSecretKey2());
   let btpUrl = config.btpUrl;
   if (!btpUrl && config.connectorUrl) {
     try {
@@ -175,7 +427,8 @@ function applyDefaults(config) {
     // Always set by logic above
   };
 }
-function buildSettlementInfo(config) {
+function buildSettlementInfo(rawConfig) {
+  const config = applyNetworkPresets(rawConfig);
   if (!config.supportedChains?.length && !config.settlementAddresses && !config.preferredTokens && !config.tokenNetworks) {
     return void 0;
   }
@@ -210,7 +463,7 @@ function fromBase64(base64) {
   }
   return bytes;
 }
-function toHex(bytes) {
+function toHex2(bytes) {
   let hex = "";
   for (const byte of bytes) {
     hex += byte.toString(16).padStart(2, "0");
@@ -220,6 +473,9 @@ function toHex(bytes) {
 function encodeUtf8(str) {
   return new TextEncoder().encode(str);
 }
+function decodeUtf8(bytes) {
+  return new TextDecoder().decode(bytes);
+}
 function isBase64(str) {
   return /^[A-Za-z0-9+/]*={0,2}$/.test(str);
 }
@@ -665,7 +921,7 @@ var IsomorphicBtpClient = class {
     if (this._isConnected) return;
     return new Promise((resolve, reject) => {
       try {
-        this.ws = new WebSocket(this.config.url);
+        this.ws = this.config.createWebSocket ? this.config.createWebSocket(this.config.url) : new WebSocket(this.config.url);
         this.ws.binaryType = "arraybuffer";
       } catch (err) {
         reject(
@@ -689,8 +945,14 @@ var IsomorphicBtpClient = class {
       this.ws.onmessage = (event) => {
         this.handleMessage(event.data);
       };
-      this.ws.onerror = () => {
-        reject(new BtpConnectionError("WebSocket connection error"));
+      this.ws.onerror = (event) => {
+        const underlying = event?.error ?? event?.message;
+        const detail = underlying instanceof Error ? underlying.message : typeof underlying === "string" ? underlying : null;
+        reject(
+          new BtpConnectionError(
+            detail ? `WebSocket connection error: ${detail}` : "WebSocket connection error"
+          )
+        );
       };
       this.ws.onclose = () => {
         this._isConnected = false;
@@ -746,6 +1008,30 @@ var IsomorphicBtpClient = class {
       this.pendingRequests.set(requestId, { resolve, reject, timeoutId });
     });
   }
+  /**
+   * Send a fire-and-forget BTP MESSAGE carrying only protocol data (no ILP
+   * packet). Used for out-of-band claim notifications that the connector's
+   * ClaimReceiver consumes via `handleClaimMessage` — there is no RESPONSE
+   * frame, so we resolve immediately after the WebSocket buffers the bytes.
+   *
+   * Mirrors `sendPacket` wire-format construction but uses an empty ILP
+   * payload and does not enroll a pending request.
+   */
+  async sendProtocolData(protocolName, contentType, data) {
+    if (!this._isConnected || !this.ws) {
+      throw new BtpConnectionError("Not connected");
+    }
+    const requestId = this.nextRequestId();
+    const btpMessage = serializeBtpMessage({
+      type: BTPMessageType.MESSAGE,
+      requestId,
+      data: {
+        protocolData: [{ protocolName, contentType, data }],
+        ilpPacket: new Uint8Array(0)
+      }
+    });
+    this.ws.send(btpMessage);
+  }
   // ─── Private ────────────────────────────────────────────────────────────
   async authenticate() {
     if (!this.ws) throw new BtpAuthError("WebSocket not connected");
@@ -789,7 +1075,9 @@ var IsomorphicBtpClient = class {
             if (message.type === BTPMessageType.ERROR) {
               const errData = message.data;
               reject(
-                new BtpAuthError(`Authentication failed: ${errData.code}`)
+                new BtpAuthError(
+                  `Authentication failed: ${errData.code} msg=${errData.message ?? ""} trigger=${errData.triggeredBy ?? ""}`
+                )
               );
             } else if (message.type === BTPMessageType.RESPONSE) {
               resolve();
@@ -901,7 +1189,8 @@ var BtpRuntimeClient = class {
     this.btpClient = new IsomorphicBtpClient({
       url: this.config.btpUrl,
       peerId: this.config.peerId,
-      authToken: this.config.authToken
+      authToken: this.config.authToken,
+      createWebSocket: this.config.createWebSocket
     });
     await this.btpClient.connect();
     this._isConnected = true;
@@ -963,6 +1252,36 @@ var BtpRuntimeClient = class {
       }
     });
   }
+  /**
+   * Send a standalone `payment-channel-claim` BTP MESSAGE (no ILP packet
+   * attached). The connector's ClaimReceiver consumes this fire-and-forget
+   * to register cumulative claim state independently of the per-packet
+   * forwarding path. Auto-reconnects on connection errors.
+   */
+  async sendClaimMessage(claim) {
+    return withRetry(() => this._sendClaimMessageOnce(claim), {
+      maxRetries: this.config.maxRetries ?? 3,
+      retryDelay: this.config.retryDelay ?? 1e3,
+      shouldRetry: (error) => {
+        if (!isConnectionError(error)) return false;
+        this._isConnected = false;
+        return true;
+      }
+    });
+  }
+  async _sendClaimMessageOnce(claim) {
+    if (!this._isConnected) {
+      await this.reconnect();
+    }
+    if (!this.btpClient) {
+      throw new BtpConnectionError("BTP client not connected");
+    }
+    await this.btpClient.sendProtocolData(
+      "payment-channel-claim",
+      1,
+      encodeUtf8(JSON.stringify(claim))
+    );
+  }
   /**
    * Single-attempt ILP packet send. Reconnects if not connected.
    */
@@ -1034,63 +1353,860 @@ var BtpRuntimeClient = class {
   }
 };
 
-// src/channel/OnChainChannelClient.ts
-import {
-  createPublicClient,
-  createWalletClient,
-  http,
-  maxUint256,
-  decodeEventLog,
-  defineChain
-} from "viem";
-var TOKEN_NETWORK_ABI = [
-  {
-    name: "openChannel",
-    type: "function",
-    stateMutability: "nonpayable",
-    inputs: [
-      { name: "participant2", type: "address" },
-      { name: "settlementTimeout", type: "uint256" }
-    ],
-    outputs: [{ type: "bytes32" }]
-  },
-  {
-    name: "setTotalDeposit",
-    type: "function",
-    stateMutability: "nonpayable",
-    inputs: [
-      { name: "channelId", type: "bytes32" },
-      { name: "participant", type: "address" },
-      { name: "totalDeposit", type: "uint256" }
-    ],
-    outputs: []
-  },
-  {
-    name: "channels",
-    type: "function",
-    stateMutability: "view",
-    inputs: [{ type: "bytes32" }],
-    outputs: [
-      { name: "settlementTimeout", type: "uint256" },
-      { name: "state", type: "uint8" },
-      { name: "closedAt", type: "uint256" },
-      { name: "openedAt", type: "uint256" },
-      { name: "participant1", type: "address" },
-      { name: "participant2", type: "address" }
-    ]
-  },
-  {
-    name: "ChannelOpened",
-    type: "event",
-    inputs: [
-      { name: "channelId", type: "bytes32", indexed: true },
-      { name: "participant1", type: "address", indexed: true },
-      { name: "participant2", type: "address", indexed: true },
-      { name: "settlementTimeout", type: "uint256", indexed: false }
-    ]
-  }
-];
-var ERC20_ABI = [
+// src/adapters/HttpIlpClient.ts
+var ILP_CLAIM_HEADER = "ILP-Payment-Channel-Claim";
+var ILP_CLAIM_WRAPPED_HEADER = "ILP-Payment-Channel-Claim-Wrapped";
+var ILP_PEER_ID_HEADER = "ILP-Peer-Id";
+var HttpIlpClient = class {
+  httpEndpoint;
+  peerId;
+  authToken;
+  timeout;
+  retryConfig;
+  httpClient;
+  createWebSocket;
+  constructor(config) {
+    this.httpEndpoint = config.httpEndpoint;
+    this.peerId = config.peerId;
+    this.authToken = config.authToken;
+    this.timeout = config.timeout ?? 3e4;
+    this.retryConfig = {
+      maxRetries: config.maxRetries ?? 3,
+      retryDelay: config.retryDelay ?? 1e3
+    };
+    this.httpClient = config.httpClient ?? fetch;
+    this.createWebSocket = config.createWebSocket;
+  }
+  /**
+   * 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.
+   */
+  async sendIlpPacket(params) {
+    return withRetry(() => this.postPrepare(params), {
+      maxRetries: this.retryConfig.maxRetries,
+      retryDelay: this.retryConfig.retryDelay,
+      exponentialBackoff: true,
+      shouldRetry: (error) => error instanceof NetworkError
+    });
+  }
+  /**
+   * Send an ILP PREPARE via `POST /ilp` with the payment-channel claim attached
+   * 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.
+   */
+  async sendIlpPacketWithClaim(params, claim) {
+    return withRetry(() => this.postPrepare(params, claim), {
+      maxRetries: this.retryConfig.maxRetries,
+      retryDelay: this.retryConfig.retryDelay,
+      exponentialBackoff: true,
+      shouldRetry: (error) => error instanceof NetworkError
+    });
+  }
+  /**
+   * Upgrade to a duplex BTP session over the SAME endpoint.
+   *
+   * Derives the `ws(s)://` URL from `httpEndpoint`, opens a WebSocket with
+   * `Sec-WebSocket-Protocol: btp` and the same `ILP-Peer-Id` + `Authorization`
+   * headers, and returns a connected {@link BtpRuntimeClient}. When auth headers
+   * are present the connector pre-authenticates the session (no in-band auth
+   * frame); without them the BtpRuntimeClient falls back to the normal BTP
+   * auth-frame flow.
+   *
+   * NOTE: passing per-connection headers + a subprotocol to a WebSocket is
+   * Node-only (the `ws` package). Browsers cannot set arbitrary request headers
+   * on a WebSocket handshake, so a browser consumer must use the gateway
+   * transport or BTP-with-auth-frame instead.
+   */
+  async upgradeToBtp() {
+    const btpUrl = httpEndpointToBtpUrl(this.httpEndpoint);
+    const createWebSocket = this.createWebSocket ?? await makeBtpWebSocketFactory(this.authHeaders());
+    const client = new BtpRuntimeClient({
+      btpUrl,
+      // BtpRuntimeClient sends an auth frame using these; when the connector
+      // pre-authenticated via Upgrade headers it accepts the (redundant) frame.
+      peerId: this.peerId ?? "client",
+      authToken: this.authToken ?? "",
+      createWebSocket
+    });
+    await client.connect();
+    return client;
+  }
+  // ─── Private ──────────────────────────────────────────────────────────────
+  authHeaders() {
+    const headers = {};
+    if (this.peerId) headers[ILP_PEER_ID_HEADER] = this.peerId;
+    if (this.authToken) headers["Authorization"] = `Bearer ${this.authToken}`;
+    return headers;
+  }
+  /**
+   * Single attempt: serialize the PREPARE, POST it, and map the response.
+   * @throws {NetworkError} On connection/timeout failures (retried).
+   * @throws {ConnectorError} On non-retryable transport errors (5xx / unexpected).
+   */
+  async postPrepare(params, claim) {
+    const requestTimeout = params.timeout ?? this.timeout;
+    const prepare = serializeIlpPrepare({
+      type: ILPPacketType.PREPARE,
+      amount: BigInt(params.amount),
+      destination: params.destination,
+      executionCondition: new Uint8Array(32),
+      expiresAt: new Date(Date.now() + requestTimeout),
+      data: fromBase64(params.data)
+    });
+    const headers = {
+      "Content-Type": "application/octet-stream",
+      ...this.authHeaders()
+    };
+    if (claim !== void 0) {
+      headers[ILP_CLAIM_HEADER] = toBase64(
+        encodeUtf8(JSON.stringify(claim))
+      );
+    }
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), requestTimeout);
+    try {
+      const response = await this.httpClient(this.httpEndpoint, {
+        method: "POST",
+        headers,
+        // Copy into a fresh ArrayBuffer so fetch sees a clean body, not a view.
+        body: prepare.slice(),
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      return await this.mapResponse(response);
+    } catch (error) {
+      clearTimeout(timeoutId);
+      throw this.mapTransportError(error, requestTimeout);
+    }
+  }
+  /**
+   * 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.
+   */
+  async mapResponse(response) {
+    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
+      };
+    }
+    const body = await response.text().catch(() => "");
+    const detail = body ? `: ${body}` : "";
+    if (response.status >= 500) {
+      throw new ConnectorError(
+        `Connector transport error (${response.status} ${response.statusText})${detail}`
+      );
+    }
+    throw new ConnectorError(
+      `ILP-over-HTTP request rejected (${response.status} ${response.statusText})${detail}`
+    );
+  }
+  mapTransportError(error, requestTimeout) {
+    if (error instanceof ConnectorError || error instanceof NetworkError) {
+      return error;
+    }
+    if (error instanceof Error && error.name === "AbortError") {
+      return new NetworkError(`Request timeout after ${requestTimeout}ms`, error);
+    }
+    if (error instanceof TypeError && (error.message.includes("fetch failed") || error.message.includes("ECONNREFUSED") || error.message.includes("ECONNRESET") || error.message.includes("ETIMEDOUT") || error.message.includes("network"))) {
+      return new NetworkError(`Network connection failed: ${error.message}`, error);
+    }
+    return new ConnectorError(
+      `Unexpected error during ILP-over-HTTP request: ${error instanceof Error ? error.message : String(error)}`,
+      error instanceof Error ? error : void 0
+    );
+  }
+};
+function httpEndpointToBtpUrl(httpEndpoint) {
+  return httpEndpoint.replace(/^https:\/\//i, "wss://").replace(/^http:\/\//i, "ws://");
+}
+async function makeBtpWebSocketFactory(headers) {
+  const { createRequire } = await import("module");
+  const require2 = createRequire(import.meta.url);
+  const WS = require2("ws");
+  const ws = WS;
+  const WSClass = typeof ws === "function" ? ws : typeof ws.default === "function" ? ws.default : typeof ws.WebSocket === "function" ? ws.WebSocket : null;
+  if (WSClass === null) {
+    throw new Error(
+      "makeBtpWebSocketFactory: require('ws') did not yield a constructor on .default, .WebSocket, or the module root."
+    );
+  }
+  return (url) => (
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    new WSClass(url, "btp", { headers })
+  );
+}
+
+// src/adapters/selectIlpTransport.ts
+function readDiscoveredIlpPeer(peer) {
+  const p = peer ?? {};
+  return {
+    btpEndpoint: typeof p["btpEndpoint"] === "string" ? p["btpEndpoint"] : void 0,
+    httpEndpoint: typeof p["httpEndpoint"] === "string" ? p["httpEndpoint"] : void 0,
+    supportsUpgrade: typeof p["supportsUpgrade"] === "boolean" ? p["supportsUpgrade"] : void 0
+  };
+}
+function selectIlpTransport(peer, options = {}) {
+  const needsDuplex = options.needsDuplex ?? false;
+  const http2 = 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 (http2 && canUpgrade) return { kind: "http-upgradable", httpEndpoint: http2 };
+    throw new Error(
+      "Duplex transport required but peer exposes neither a btpEndpoint nor an upgradable httpEndpoint"
+    );
+  }
+  if (http2) return { kind: "http", httpEndpoint: http2, canUpgrade };
+  if (btp) return { kind: "btp", btpEndpoint: btp };
+  throw new Error("Peer exposes neither an httpEndpoint nor a btpEndpoint");
+}
+
+// src/channel/OnChainChannelClient.ts
+import {
+  createPublicClient,
+  createWalletClient,
+  http,
+  maxUint256,
+  decodeEventLog,
+  defineChain
+} from "viem";
+import { ed25519 as ed255192 } from "@noble/curves/ed25519.js";
+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 { base58Encode, base58Decode } from "@toon-protocol/core";
+var TOKEN_PROGRAM_ID = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
+var SYSTEM_PROGRAM_ID = "11111111111111111111111111111111";
+var RENT_SYSVAR_ID = "SysvarRent111111111111111111111111111111111";
+var IX_INITIALIZE_CHANNEL = new Uint8Array([1, 0, 0, 0, 0, 0, 0, 0]);
+var IX_DEPOSIT = new Uint8Array([2, 0, 0, 0, 0, 0, 0, 0]);
+var CHANNEL_DISCRIMINATOR = new Uint8Array([
+  112,
+  99,
+  104,
+  97,
+  110,
+  110,
+  101,
+  108
+]);
+var CHANNEL_ACCOUNT_SIZE = 178;
+var MAX_U64 = (1n << 64n) - 1n;
+function writeU64LE(buf, offset, value) {
+  if (value < 0n || value > MAX_U64) {
+    throw new RangeError(`Value ${value} outside u64 range [0, 2^64-1]`);
+  }
+  for (let i = 0; i < 8; i++) {
+    buf[offset + i] = Number(value >> BigInt(i * 8) & 0xffn);
+  }
+}
+function padTo32(bytes) {
+  if (bytes.length === 32) return bytes;
+  if (bytes.length > 32) return bytes.slice(bytes.length - 32);
+  const padded = new Uint8Array(32);
+  padded.set(bytes, 32 - bytes.length);
+  return padded;
+}
+function sortPubkeys(a, b) {
+  for (let i = 0; i < 32; i++) {
+    const ai = a[i] ?? 0;
+    const bi = b[i] ?? 0;
+    if (ai < bi) return [a, b];
+    if (ai > bi) return [b, a];
+  }
+  return [a, b];
+}
+function modPow(base, exp, mod) {
+  let result = 1n;
+  base = (base % mod + mod) % mod;
+  while (exp > 0n) {
+    if (exp & 1n) result = result * base % mod;
+    exp >>= 1n;
+    base = base * base % mod;
+  }
+  return result;
+}
+function modInverse(a, m) {
+  return modPow((a % m + m) % m, m - 2n, m);
+}
+function isOnCurve(bytes) {
+  const P = (1n << 255n) - 19n;
+  const yBytes = new Uint8Array(32);
+  yBytes.set(bytes);
+  yBytes[31] = (yBytes[31] ?? 0) & 127;
+  let y = 0n;
+  for (let i = 0; i < 32; i++) {
+    y |= BigInt(yBytes[i] ?? 0) << BigInt(i * 8);
+  }
+  if (y >= P) return true;
+  const y2 = y * y % P;
+  const D = (P - 121665n * modInverse(121666n, P) % P + P) % P;
+  const numerator = (y2 - 1n + P) % P;
+  const denominator = (D * y2 + 1n) % P;
+  const x2 = numerator * modInverse(denominator, P) % P;
+  if (x2 === 0n) return true;
+  return modPow(x2, (P - 1n) / 2n, P) === 1n;
+}
+function findProgramAddress(seeds, programId) {
+  const PDA_MARKER = new TextEncoder().encode("ProgramDerivedAddress");
+  for (let bump = 255; bump >= 0; bump--) {
+    const allSeeds = [...seeds, new Uint8Array([bump])];
+    let totalLen = programId.length + PDA_MARKER.length;
+    for (const s of allSeeds) totalLen += s.length;
+    const input = new Uint8Array(totalLen);
+    let offset = 0;
+    for (const s of allSeeds) {
+      input.set(s, offset);
+      offset += s.length;
+    }
+    input.set(programId, offset);
+    offset += programId.length;
+    input.set(PDA_MARKER, offset);
+    const hash = sha256(input);
+    if (!isOnCurve(hash)) return { pda: hash, bump };
+  }
+  throw new Error("Could not find a viable PDA bump seed");
+}
+function deriveChannelPDA(participantA, participantB, tokenMint, programId) {
+  const a = padTo32(base58Decode(participantA));
+  const b = padTo32(base58Decode(participantB));
+  const mint = padTo32(base58Decode(tokenMint));
+  const program = padTo32(base58Decode(programId));
+  const [min, max] = sortPubkeys(a, b);
+  const seeds = [new TextEncoder().encode("channel"), min, max, mint];
+  const { pda, bump } = findProgramAddress(seeds, program);
+  return { pda: base58Encode(pda), bump };
+}
+function deriveVaultPDA(channelPDA, programId) {
+  const channel = padTo32(base58Decode(channelPDA));
+  const program = padTo32(base58Decode(programId));
+  const seeds = [new TextEncoder().encode("vault"), channel];
+  const { pda, bump } = findProgramAddress(seeds, program);
+  return { pda: base58Encode(pda), bump };
+}
+function buildBalanceProofMessage(channelPDA, nonce, transferredAmount) {
+  const message = new Uint8Array(48);
+  message.set(padTo32(base58Decode(channelPDA)), 0);
+  writeU64LE(message, 32, nonce);
+  writeU64LE(message, 40, transferredAmount);
+  return message;
+}
+var rpcIdCounter = 1;
+async function solanaRpc(rpcUrl, method, params = []) {
+  const res = await fetch(rpcUrl, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      jsonrpc: "2.0",
+      method,
+      params,
+      id: rpcIdCounter++
+    }),
+    signal: AbortSignal.timeout(3e4)
+  });
+  const json = await res.json();
+  if (json.error) {
+    throw new Error(
+      `Solana RPC error [${method}]: ${json.error.message} (code ${json.error.code})`
+    );
+  }
+  return json.result;
+}
+async function getLatestBlockhash(rpcUrl) {
+  const result = await solanaRpc(rpcUrl, "getLatestBlockhash", [
+    { commitment: "confirmed" }
+  ]);
+  return result.value.blockhash;
+}
+async function getAccountInfo(rpcUrl, pubkey) {
+  const result = await solanaRpc(rpcUrl, "getAccountInfo", [
+    pubkey,
+    { encoding: "base64", commitment: "confirmed" }
+  ]);
+  return result.value;
+}
+async function waitForConfirmation(rpcUrl, signature, timeoutMs = 3e4) {
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    const result = await solanaRpc(rpcUrl, "getSignatureStatuses", [
+      [signature]
+    ]);
+    const status = result.value[0];
+    if (status?.confirmationStatus === "confirmed" || status?.confirmationStatus === "finalized") {
+      if (status.err) {
+        throw new Error(
+          `Transaction ${signature} failed: ${JSON.stringify(status.err)}`
+        );
+      }
+      return;
+    }
+    await new Promise((r) => setTimeout(r, 500));
+  }
+  throw new Error(
+    `Transaction ${signature} not confirmed within ${timeoutMs}ms`
+  );
+}
+function compactU16Size(value) {
+  if (value > 65535) {
+    throw new RangeError(`compact-u16 value ${value} exceeds u16 max (0xFFFF)`);
+  }
+  return value < 128 ? 1 : value < 16384 ? 2 : 3;
+}
+function writeCompactU16(buf, offset, value) {
+  if (value < 128) {
+    buf[offset++] = value;
+  } else if (value < 16384) {
+    buf[offset++] = value & 127 | 128;
+    buf[offset++] = value >> 7;
+  } else {
+    buf[offset++] = value & 127 | 128;
+    buf[offset++] = value >> 7 & 127 | 128;
+    buf[offset++] = value >> 14;
+  }
+  return offset;
+}
+async function buildAndSendTransaction(rpcUrl, feePayer, instructions, additionalSigners = []) {
+  const blockhash = await getLatestBlockhash(rpcUrl);
+  const feePayerPubkey = base58Encode(feePayer.publicKey);
+  const accountMap = /* @__PURE__ */ new Map();
+  accountMap.set(feePayerPubkey, {
+    pubkey: feePayerPubkey,
+    isSigner: true,
+    isWritable: true
+  });
+  for (const ix of instructions) {
+    for (const key of ix.keys) {
+      const existing = accountMap.get(key.pubkey);
+      if (existing) {
+        existing.isSigner = existing.isSigner || key.isSigner;
+        existing.isWritable = existing.isWritable || key.isWritable;
+      } else {
+        accountMap.set(key.pubkey, { ...key });
+      }
+    }
+    if (!accountMap.has(ix.programId)) {
+      accountMap.set(ix.programId, {
+        pubkey: ix.programId,
+        isSigner: false,
+        isWritable: false
+      });
+    }
+  }
+  const accounts = [...accountMap.values()].sort((a, b) => {
+    if (a.pubkey === feePayerPubkey) return -1;
+    if (b.pubkey === feePayerPubkey) return 1;
+    const aScore = (a.isSigner ? 2 : 0) + (a.isWritable ? 1 : 0);
+    const bScore = (b.isSigner ? 2 : 0) + (b.isWritable ? 1 : 0);
+    return bScore - aScore;
+  });
+  const numSigners = accounts.filter((a) => a.isSigner).length;
+  const numReadonlySigners = accounts.filter(
+    (a) => a.isSigner && !a.isWritable
+  ).length;
+  const numReadonlyNonSigners = accounts.filter(
+    (a) => !a.isSigner && !a.isWritable
+  ).length;
+  const accountIndexMap = /* @__PURE__ */ new Map();
+  accounts.forEach((a, i) => accountIndexMap.set(a.pubkey, i));
+  const compiled = instructions.map((ix) => ({
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- programId added to accountMap above
+    programIdIndex: accountIndexMap.get(ix.programId),
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- every key added to accountMap above
+    accountIndices: ix.keys.map((k) => accountIndexMap.get(k.pubkey)),
+    data: ix.data
+  }));
+  const blockhashBytes = base58Decode(blockhash);
+  let instructionSize = compactU16Size(compiled.length);
+  for (const ix of compiled) {
+    instructionSize += 1;
+    instructionSize += compactU16Size(ix.accountIndices.length) + ix.accountIndices.length;
+    instructionSize += compactU16Size(ix.data.length) + ix.data.length;
+  }
+  const messageSize = 3 + compactU16Size(accounts.length) + 32 * accounts.length + 32 + instructionSize;
+  const message = new Uint8Array(messageSize);
+  let offset = 0;
+  message[offset++] = numSigners;
+  message[offset++] = numReadonlySigners;
+  message[offset++] = numReadonlyNonSigners;
+  offset = writeCompactU16(message, offset, accounts.length);
+  for (const acct of accounts) {
+    message.set(padTo32(base58Decode(acct.pubkey)), offset);
+    offset += 32;
+  }
+  message.set(padTo32(blockhashBytes), offset);
+  offset += 32;
+  offset = writeCompactU16(message, offset, compiled.length);
+  for (const ix of compiled) {
+    message[offset++] = ix.programIdIndex;
+    offset = writeCompactU16(message, offset, ix.accountIndices.length);
+    for (const idx of ix.accountIndices) message[offset++] = idx;
+    offset = writeCompactU16(message, offset, ix.data.length);
+    message.set(ix.data, offset);
+    offset += ix.data.length;
+  }
+  const finalMessage = message.slice(0, offset);
+  const allSigners = [feePayer, ...additionalSigners];
+  const signerPubkeys = accounts.filter((a) => a.isSigner).map((a) => a.pubkey);
+  const signatures = [];
+  for (const signerPubkey of signerPubkeys) {
+    const signer = allSigners.find(
+      (s) => base58Encode(s.publicKey) === signerPubkey
+    );
+    if (!signer) throw new Error(`Missing signer for ${signerPubkey}`);
+    signatures.push(ed25519.sign(finalMessage, signer.privateKey));
+  }
+  const txSize = compactU16Size(signatures.length) + signatures.length * 64 + finalMessage.length;
+  const tx = new Uint8Array(txSize);
+  let txOffset = 0;
+  txOffset = writeCompactU16(tx, txOffset, signatures.length);
+  for (const sig of signatures) {
+    tx.set(sig, txOffset);
+    txOffset += 64;
+  }
+  tx.set(finalMessage, txOffset);
+  const txBase64 = Buffer.from(tx).toString("base64");
+  const txSig = await solanaRpc(rpcUrl, "sendTransaction", [
+    txBase64,
+    {
+      encoding: "base64",
+      skipPreflight: false,
+      preflightCommitment: "confirmed"
+    }
+  ]);
+  await waitForConfirmation(rpcUrl, txSig);
+  return txSig;
+}
+var STATE_MAP = ["opened", "closed", "settled"];
+async function getChannelAccountState(rpcUrl, channelPDA) {
+  const info = await getAccountInfo(rpcUrl, channelPDA);
+  if (!info) return { exists: false };
+  const data = new Uint8Array(Buffer.from(info.data[0], "base64"));
+  if (data.length < CHANNEL_ACCOUNT_SIZE) return { exists: false };
+  for (let i = 0; i < 8; i++) {
+    if (data[i] !== CHANNEL_DISCRIMINATOR[i]) return { exists: false };
+  }
+  return {
+    exists: true,
+    state: STATE_MAP[data[160] ?? 0] ?? "opened",
+    participantA: base58Encode(data.slice(8, 40)),
+    participantB: base58Encode(data.slice(40, 72))
+  };
+}
+async function openSolanaChannel(params) {
+  const {
+    rpcUrl,
+    programId,
+    tokenMint,
+    payerSeed,
+    payerPubkey,
+    peerPubkey,
+    challengeDuration
+  } = params;
+  const { pda: channelPDA } = deriveChannelPDA(
+    payerPubkey,
+    peerPubkey,
+    tokenMint,
+    programId
+  );
+  const existing = await getChannelAccountState(rpcUrl, channelPDA);
+  if (existing.exists) {
+    return { channelPDA, opened: false };
+  }
+  const payerPublicKey = padTo32(base58Decode(payerPubkey));
+  const payer = { publicKey: payerPublicKey, privateKey: payerSeed };
+  const { pda: vaultPDA } = deriveVaultPDA(channelPDA, programId);
+  const initData = new Uint8Array(16);
+  initData.set(IX_INITIALIZE_CHANNEL, 0);
+  writeU64LE(initData, 8, challengeDuration);
+  const initTxSignature = await buildAndSendTransaction(rpcUrl, payer, [
+    {
+      programId,
+      keys: [
+        { pubkey: payerPubkey, isSigner: true, isWritable: true },
+        { pubkey: payerPubkey, isSigner: false, isWritable: false },
+        // participant A
+        { pubkey: peerPubkey, isSigner: false, isWritable: false },
+        // participant B
+        { pubkey: tokenMint, isSigner: false, isWritable: false },
+        { pubkey: channelPDA, isSigner: false, isWritable: true },
+        { pubkey: vaultPDA, isSigner: false, isWritable: true },
+        { pubkey: SYSTEM_PROGRAM_ID, isSigner: false, isWritable: false },
+        { pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
+        { pubkey: RENT_SYSVAR_ID, isSigner: false, isWritable: false }
+      ],
+      data: initData
+    }
+  ]);
+  let depositTxSignature;
+  if (params.deposit && params.deposit.amount > 0n) {
+    const depositData = new Uint8Array(16);
+    depositData.set(IX_DEPOSIT, 0);
+    writeU64LE(depositData, 8, params.deposit.amount);
+    depositTxSignature = await buildAndSendTransaction(rpcUrl, payer, [
+      {
+        programId,
+        keys: [
+          { pubkey: payerPubkey, isSigner: true, isWritable: false },
+          {
+            pubkey: params.deposit.payerTokenAccount,
+            isSigner: false,
+            isWritable: true
+          },
+          { pubkey: vaultPDA, isSigner: false, isWritable: true },
+          { pubkey: channelPDA, isSigner: false, isWritable: true },
+          { pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false }
+        ],
+        data: depositData
+      }
+    ]);
+  }
+  return { channelPDA, opened: true, initTxSignature, depositTxSignature };
+}
+
+// src/channel/mina-channel-open.ts
+import { hexToMinaBase58PrivateKey as hexToMinaBase58PrivateKey2 } from "@toon-protocol/core";
+var cachedO1js = null;
+var cachedPaymentChannel = null;
+var compiledContract = null;
+var runtimeOverride = null;
+async function loadMinaRuntime() {
+  if (cachedO1js && cachedPaymentChannel) {
+    return { o1js: cachedO1js, PaymentChannel: cachedPaymentChannel };
+  }
+  if (runtimeOverride) {
+    const injected = await runtimeOverride();
+    cachedO1js = injected.o1js;
+    cachedPaymentChannel = injected.PaymentChannel;
+    return injected;
+  }
+  const { createRequire } = await import("module");
+  const nodePath = await import("path");
+  const requireHere = createRequire(import.meta.url);
+  const mzkPkgPath = requireHere.resolve(
+    "@toon-protocol/mina-zkapp/package.json"
+  );
+  const requireFromMzk = createRequire(mzkPkgPath);
+  const o1js = requireFromMzk("o1js");
+  const mzkPkgJson = requireFromMzk(mzkPkgPath);
+  const mzkDir = nodePath.dirname(mzkPkgPath);
+  const mzkEntry = nodePath.join(mzkDir, mzkPkgJson.main ?? "dist/index.js");
+  const mzk = requireFromMzk(mzkEntry);
+  const PaymentChannel = mzk.PaymentChannel ?? mzk.default?.PaymentChannel;
+  if (!PaymentChannel) {
+    throw new Error(
+      "@toon-protocol/mina-zkapp does not export PaymentChannel \u2014 cannot open a Mina channel"
+    );
+  }
+  cachedO1js = o1js;
+  cachedPaymentChannel = PaymentChannel;
+  return { o1js, PaymentChannel };
+}
+async function getO1js() {
+  return (await loadMinaRuntime()).o1js;
+}
+async function getCompiledPaymentChannel() {
+  const { PaymentChannel } = await loadMinaRuntime();
+  if (!compiledContract) {
+    await PaymentChannel.compile();
+    compiledContract = PaymentChannel;
+  }
+  return compiledContract;
+}
+var MINA_CHANNEL_STATE_OPEN = 1n;
+var MINA_CHANNEL_STATE_UNINITIALIZED = 0n;
+async function openMinaChannelOnChain(params) {
+  const { Mina, PrivateKey, PublicKey, Field, AccountUpdate, fetchAccount } = await getO1js();
+  const network = Mina.Network(params.graphqlUrl);
+  Mina.setActiveInstance(network);
+  const txFee = params.feeNanomina ?? 100000000n;
+  const payerKeyBase58 = hexToMinaBase58PrivateKey2(params.payerPrivateKey);
+  const payerPrivateKey = PrivateKey.fromBase58(payerKeyBase58);
+  const payerPublicKey = payerPrivateKey.toPublicKey();
+  const zkAppPublicKey = PublicKey.fromBase58(params.zkAppAddress);
+  const readChannelState = async () => {
+    const res = await fetchAccount({ publicKey: zkAppPublicKey });
+    if (res.error || !res.account) {
+      throw new Error(
+        `Mina zkApp account ${params.zkAppAddress} not found on-chain (${String(
+          res.error
+        )}) \u2014 deploy the PaymentChannel zkApp before opening a channel`
+      );
+    }
+    const appState = res.account.zkapp?.appState;
+    const raw = appState?.[3]?.toString() ?? "0";
+    return BigInt(raw);
+  };
+  const readDepositTotal = async () => {
+    const res = await fetchAccount({ publicKey: zkAppPublicKey });
+    if (res.error || !res.account) {
+      throw new Error(
+        `Mina zkApp account ${params.zkAppAddress} not found on-chain (${String(
+          res.error
+        )}) \u2014 deploy the PaymentChannel zkApp before opening a channel`
+      );
+    }
+    const appState = res.account.zkapp?.appState;
+    const raw = appState?.[4]?.toString() ?? "0";
+    return BigInt(raw);
+  };
+  const currentState = await readChannelState();
+  await fetchAccount({ publicKey: payerPublicKey });
+  let opened = false;
+  let initTxHash;
+  let zkApp;
+  const getZkApp = async () => {
+    if (!zkApp) {
+      const PaymentChannel = await getCompiledPaymentChannel();
+      zkApp = new PaymentChannel(zkAppPublicKey);
+    }
+    return zkApp;
+  };
+  if (currentState === MINA_CHANNEL_STATE_UNINITIALIZED) {
+    const channel = await getZkApp();
+    const participantA = payerPublicKey;
+    const participantB = params.peerPublicKey ? PublicKey.fromBase58(params.peerPublicKey) : payerPublicKey;
+    const nonce = Field(0);
+    const timeoutField = Field((params.timeout ?? 86400n).toString());
+    const tokenIdField = Field(params.tokenId ?? "1");
+    await fetchAccount({ publicKey: zkAppPublicKey });
+    await fetchAccount({ publicKey: payerPublicKey });
+    const initTx = await Mina.transaction(
+      { sender: payerPublicKey, fee: Number(txFee) },
+      async () => {
+        await channel.initializeChannel(
+          participantA,
+          participantB,
+          nonce,
+          timeoutField,
+          tokenIdField
+        );
+      }
+    );
+    await initTx.prove();
+    const sentInit = await initTx.sign([payerPrivateKey]).send();
+    initTxHash = sentInit.hash ?? void 0;
+    opened = true;
+    await sentInit.wait();
+    await fetchAccount({ publicKey: zkAppPublicKey });
+    await fetchAccount({ publicKey: payerPublicKey });
+  } else if (currentState !== MINA_CHANNEL_STATE_OPEN) {
+    throw new Error(
+      `Mina channel ${params.zkAppAddress} is in state ${currentState} (not UNINITIALIZED/OPEN) \u2014 cannot open`
+    );
+  }
+  let depositTxHash;
+  if (params.deposit && params.deposit.amount > 0n) {
+    const channel = await getZkApp();
+    await fetchAccount({ publicKey: zkAppPublicKey });
+    const amountField = Field(params.deposit.amount.toString());
+    const depositTx = await Mina.transaction(
+      { sender: payerPublicKey, fee: Number(txFee) },
+      async () => {
+        await channel.deposit(amountField, payerPublicKey);
+      }
+    );
+    await depositTx.prove();
+    const sentDeposit = await depositTx.sign([payerPrivateKey]).send();
+    depositTxHash = sentDeposit.hash ?? void 0;
+    await sentDeposit.wait();
+    await fetchAccount({ publicKey: zkAppPublicKey });
+    await fetchAccount({ publicKey: payerPublicKey });
+  }
+  let finalState;
+  try {
+    finalState = Number(await readChannelState());
+  } catch {
+    finalState = opened ? Number(MINA_CHANNEL_STATE_OPEN) : Number(currentState);
+  }
+  if (opened && finalState === Number(MINA_CHANNEL_STATE_UNINITIALIZED)) {
+    finalState = Number(MINA_CHANNEL_STATE_OPEN);
+  }
+  void AccountUpdate;
+  let depositTotal;
+  try {
+    depositTotal = await readDepositTotal();
+  } catch {
+    depositTotal = 0n;
+  }
+  return {
+    zkAppAddress: params.zkAppAddress,
+    opened,
+    initTxHash,
+    depositTxHash,
+    channelState: finalState,
+    depositTotal
+  };
+}
+
+// src/channel/OnChainChannelClient.ts
+var TOKEN_NETWORK_ABI = [
+  {
+    name: "openChannel",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "participant2", type: "address" },
+      { name: "settlementTimeout", type: "uint256" }
+    ],
+    outputs: [{ type: "bytes32" }]
+  },
+  {
+    name: "setTotalDeposit",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "channelId", type: "bytes32" },
+      { name: "participant", type: "address" },
+      { name: "totalDeposit", type: "uint256" }
+    ],
+    outputs: []
+  },
+  {
+    name: "channels",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ type: "bytes32" }],
+    outputs: [
+      { name: "settlementTimeout", type: "uint256" },
+      { name: "state", type: "uint8" },
+      { name: "closedAt", type: "uint256" },
+      { name: "openedAt", type: "uint256" },
+      { name: "participant1", type: "address" },
+      { name: "participant2", type: "address" }
+    ]
+  },
+  {
+    name: "ChannelOpened",
+    type: "event",
+    inputs: [
+      { name: "channelId", type: "bytes32", indexed: true },
+      { name: "participant1", type: "address", indexed: true },
+      { name: "participant2", type: "address", indexed: true },
+      { name: "settlementTimeout", type: "uint256", indexed: false }
+    ]
+  }
+];
+var ERC20_ABI = [
   {
     name: "approve",
     type: "function",
@@ -1112,7 +2228,7 @@ var ERC20_ABI = [
     outputs: [{ type: "uint256" }]
   }
 ];
-var STATE_MAP = {
+var STATE_MAP2 = {
   0: "settled",
   1: "open",
   2: "closed",
@@ -1130,6 +2246,29 @@ var OnChainChannelClient = class {
     this.solanaConfig = config.solanaConfig;
     this.minaConfig = config.minaConfig;
   }
+  /**
+   * Late-binds the Solana channel config.
+   *
+   * `ToonClient.start()` derives the Solana Ed25519 keypair from the client's
+   * mnemonic asynchronously (after this client is constructed), so the keypair
+   * is injected here rather than at construction. Same keypair as the
+   * registered Solana signer — guarantees the channel-open key and the
+   * claim-signing key match.
+   */
+  setSolanaConfig(config) {
+    this.solanaConfig = config;
+  }
+  /**
+   * Late-binds the Mina channel config.
+   *
+   * Parallel to `setSolanaConfig`: `ToonClient.start()` derives the Mina private
+   * key from the client's mnemonic asynchronously (after this client is
+   * constructed), so the key is injected here rather than at construction. Same
+   * key as the registered Mina signer.
+   */
+  setMinaConfig(config) {
+    this.minaConfig = config;
+  }
   /**
    * Parse chain identifier to extract chainId.
    * Format: "evm:{network}:{chainId}" e.g., "evm:anvil:31337"
@@ -1196,7 +2335,19 @@ var OnChainChannelClient = class {
     return this.openEvmChannel(params);
   }
   /**
-   * Opens a Solana payment channel (PDA creation).
+   * Opens a REAL on-chain Solana payment channel.
+   *
+   * Derives the connector-parity channel PDA
+   * (`[b"channel", min_pubkey, max_pubkey, token_mint]`), submits the
+   * `initialize_channel` instruction (+ optional `deposit`) to the deployed
+   * payment-channel program, and returns the base58 PDA as the channel id. That
+   * PDA is what the claim carries as `channelAccount`, and the on-chain channel
+   * is what the connector's `verifySolanaClaim` reads via
+   * `provider.getChannelState` before accepting the claim.
+   *
+   * Mirrors `openEvmChannel`'s open(+deposit) structure. Idempotent: if the
+   * channel account already exists on-chain, returns its PDA without
+   * re-initializing.
    */
   async openSolanaChannel(params) {
     if (!this.solanaConfig) {
@@ -1204,23 +2355,72 @@ var OnChainChannelClient = class {
         "Solana channel config not provided \u2014 cannot open Solana channel"
       );
     }
-    const encoder = new TextEncoder();
-    const channelSeed = encoder.encode(
-      `channel:${toHex(this.solanaConfig.keypair).slice(0, 32)}:${params.peerAddress}:${Date.now()}`
+    const cfg = this.solanaConfig;
+    const payerSeed = cfg.keypair.slice(0, 32);
+    const payerPubkey = base58Encode2(
+      new Uint8Array(ed255192.getPublicKey(payerSeed))
     );
-    const channelIdBytes = new Uint8Array(
-      await crypto.subtle.digest("SHA-256", channelSeed)
+    const tokenMint = params.token ?? cfg.tokenMint;
+    if (!tokenMint) {
+      throw new Error(
+        "Solana channel requires a token mint (OpenChannelParams.token or solanaConfig.tokenMint)"
+      );
+    }
+    if (!params.peerAddress) {
+      throw new Error(
+        "Solana channel requires peerAddress (apex settlement pubkey, base58)"
+      );
+    }
+    const challengeDuration = BigInt(
+      cfg.challengeDuration ?? params.settlementTimeout ?? 86400
     );
-    const channelId = "0x" + toHex(channelIdBytes);
-    this.channelContext.set(channelId, {
+    const deposit = cfg.deposit ? {
+      amount: BigInt(cfg.deposit.amount),
+      payerTokenAccount: cfg.deposit.payerTokenAccount
+    } : void 0;
+    const { channelPDA } = await openSolanaChannel({
+      rpcUrl: cfg.rpcUrl,
+      programId: cfg.programId,
+      tokenMint,
+      payerSeed,
+      payerPubkey,
+      peerPubkey: params.peerAddress,
+      challengeDuration,
+      deposit
+    });
+    this.channelContext.set(channelPDA, {
       chain: params.chain,
-      tokenNetworkAddress: this.solanaConfig.programId
+      tokenNetworkAddress: cfg.programId
     });
-    return { channelId, status: "opening" };
+    return { channelId: channelPDA, status: "opening" };
   }
   /**
-   * Opens a Mina payment channel (zkApp state transition).
-   * Dynamically imports o1js to avoid bundle bloat.
+   * Opens a REAL on-chain Mina payment channel on the deployed `PaymentChannel`
+   * zkApp.
+   *
+   * The zkApp is deployed out-of-band (the operator/e2e harness deploys it
+   * deterministically and advertises its B62 address). This client then calls
+   * `initializeChannel` on that zkApp so its on-chain `channelState` becomes
+   * `OPEN` — which is what the connector's `MinaPaymentChannelSDK.getChannelState`
+   * reads to return status `'opened'` (claim verification otherwise fails with
+   * `mina_claim_verification_failed`). The deployed zkApp address IS the channel
+   * id: `MinaClaimMessage.zkAppAddress` is both the claim's channel identifier
+   * AND the channel-hash preimage the off-chain proof binds to (see
+   * `mina-payment-channel.ts`), so the channel-open id and the claim's channel id
+   * are guaranteed identical.
+   *
+   * This is the Mina analog of `openSolanaChannel` (connector#105): the client
+   * opens its own per-channel on-chain state (initialize + optional deposit). The
+   * heavyweight o1js + `@toon-protocol/mina-zkapp` proof work is lazily imported
+   * inside `openMinaChannelOnChain` so npm consumers who never open a Mina
+   * channel don't pay the o1js cost.
+   *
+   * Idempotent: if the on-chain channel is already `OPEN`, the opener returns
+   * without re-initializing.
+   *
+   * NOTE: full on-chain Mina SETTLE remains gated by the connector-side
+   * settlement-executor (the same blocker that stops the Solana SETTLE); reaching
+   * `opened` + a stored claim is parity with Solana.
    */
   async openMinaChannel(params) {
     if (!this.minaConfig) {
@@ -1228,19 +2428,41 @@ var OnChainChannelClient = class {
         "Mina channel config not provided \u2014 cannot open Mina channel"
       );
     }
-    const encoder = new TextEncoder();
-    const channelSeed = encoder.encode(
-      `channel:${this.minaConfig.privateKey.slice(0, 16)}:${params.peerAddress}:${Date.now()}`
-    );
-    const channelIdBytes = new Uint8Array(
-      await crypto.subtle.digest("SHA-256", channelSeed)
+    const zkAppAddress = this.minaConfig.zkAppAddress;
+    if (!zkAppAddress) {
+      throw new Error(
+        "Mina channel requires a deployed zkAppAddress (minaConfig.zkAppAddress)"
+      );
+    }
+    if (!params.peerAddress) {
+      throw new Error(
+        "Mina channel requires peerAddress (apex Mina settlement B62) so the on-chain channel is opened two-party \u2014 the participant-form claim cannot settle against a single-party channel"
+      );
+    }
+    const timeout = BigInt(
+      this.minaConfig.challengeDuration ?? params.settlementTimeout ?? 86400
     );
-    const channelId = "0x" + toHex(channelIdBytes);
-    this.channelContext.set(channelId, {
+    const deposit = this.minaConfig.deposit ? { amount: BigInt(this.minaConfig.deposit.amount) } : void 0;
+    const openResult = await openMinaChannelOnChain({
+      graphqlUrl: this.minaConfig.graphqlUrl,
+      zkAppAddress,
+      payerPrivateKey: this.minaConfig.privateKey,
+      // params.peerAddress is the apex Mina settlement B62 pubkey (participantB).
+      peerPublicKey: params.peerAddress,
+      timeout,
+      tokenId: this.minaConfig.tokenId,
+      deposit,
+      networkId: this.minaConfig.networkId
+    });
+    this.channelContext.set(zkAppAddress, {
       chain: params.chain,
-      tokenNetworkAddress: this.minaConfig.zkAppAddress
+      tokenNetworkAddress: zkAppAddress
     });
-    return { channelId, status: "opening" };
+    return {
+      channelId: zkAppAddress,
+      status: "opening",
+      depositTotal: openResult.depositTotal
+    };
   }
   /**
    * Opens an EVM payment channel on-chain.
@@ -1336,6 +2558,17 @@ var OnChainChannelClient = class {
         `No context for channel "${channelId}". Channel must be opened via this client first.`
       );
     }
+    if (context.chain.split(":")[0] === "mina") {
+      return { channelId, status: "open", chain: context.chain };
+    }
+    if (context.chain.split(":")[0] === "solana" && this.solanaConfig) {
+      const account = await getChannelAccountState(
+        this.solanaConfig.rpcUrl,
+        channelId
+      );
+      const status2 = !account.exists ? "settled" : account.state === "opened" ? "open" : account.state === "closed" ? "closed" : "settled";
+      return { channelId, status: status2, chain: context.chain };
+    }
     const { publicClient } = this.createClients(context.chain);
     const result = await publicClient.readContract({
       address: context.tokenNetworkAddress,
@@ -1344,7 +2577,7 @@ var OnChainChannelClient = class {
       args: [channelId]
     });
     const [, state] = result;
-    const status = STATE_MAP[state] ?? "settled";
+    const status = STATE_MAP2[state] ?? "settled";
     return {
       channelId,
       status,
@@ -1354,8 +2587,8 @@ var OnChainChannelClient = class {
 };
 
 // src/signing/evm-signer.ts
-import { privateKeyToAccount } from "viem/accounts";
-import { toHex as toHex2 } from "viem";
+import { privateKeyToAccount as privateKeyToAccount2 } from "viem/accounts";
+import { toHex as toHex3 } from "viem";
 function getBalanceProofDomain(chainId, tokenNetworkAddress) {
   return {
     name: "TokenNetwork",
@@ -1382,11 +2615,11 @@ var EvmSigner = class {
   constructor(privateKey) {
     let hexKey;
     if (privateKey instanceof Uint8Array) {
-      hexKey = toHex2(privateKey);
+      hexKey = toHex3(privateKey);
     } else {
       hexKey = privateKey.startsWith("0x") ? privateKey : `0x${privateKey}`;
     }
-    this._account = privateKeyToAccount(hexKey);
+    this._account = privateKeyToAccount2(hexKey);
   }
   /** Derived 0x EVM address */
   get address() {
@@ -1465,24 +2698,118 @@ var EvmSigner = class {
   }
 };
 
+// src/transport/index.ts
+function isAnyoneHost(url) {
+  if (!url) return false;
+  try {
+    const withScheme = /:\/\//.test(url) ? url : `ws://${url}`;
+    const host = new URL(withScheme).hostname.toLowerCase();
+    return host.endsWith(".anyone");
+  } catch {
+    return false;
+  }
+}
+async function resolveTransport(transport, originalBtpUrl, originalConnectorUrl, managedProxyOptions) {
+  const hasExplicitProxy = !!transport && (transport.type === "socks5" || transport.type === "gateway");
+  const envProxy = process.env["ANYONE_PROXY_URLS"];
+  if (!hasExplicitProxy && managedProxyOptions?.managedAnonProxy !== false && !envProxy && isAnyoneHost(originalBtpUrl)) {
+    const { startManagedAnonProxy: startManagedAnonProxy2 } = await import("./anon-proxy-W3KMM7GU.js");
+    const { createSocks5WebSocketFactory, createSocks5Fetch } = await import("./socks5-WTJBYGME.js");
+    const proxy = await startManagedAnonProxy2({
+      ...managedProxyOptions?.managedAnonSocksPort !== void 0 ? { socksPort: managedProxyOptions.managedAnonSocksPort } : {}
+    });
+    try {
+      return {
+        createWebSocket: createSocks5WebSocketFactory(proxy.socksProxy),
+        httpClient: createSocks5Fetch(proxy.socksProxy),
+        stopManagedProxy: proxy.stop
+      };
+    } catch (err) {
+      await proxy.stop();
+      throw err;
+    }
+  }
+  if (!transport || transport.type === "direct") {
+    return {};
+  }
+  if (transport.type === "socks5") {
+    const {
+      createSocks5WebSocketFactory,
+      createSocks5Fetch,
+      probeSocks5Proxy
+    } = await import("./socks5-WTJBYGME.js");
+    await probeSocks5Proxy(transport.socksProxy);
+    return {
+      createWebSocket: createSocks5WebSocketFactory(transport.socksProxy),
+      httpClient: createSocks5Fetch(transport.socksProxy)
+    };
+  }
+  if (transport.type === "gateway") {
+    const { rewriteUrlsForGateway } = await import("./gateway-QOK47RKS.js");
+    const rewritten = rewriteUrlsForGateway(
+      transport.gatewayUrl,
+      originalBtpUrl,
+      originalConnectorUrl
+    );
+    return {
+      btpUrl: rewritten.btpUrl,
+      connectorUrl: rewritten.connectorUrl
+    };
+  }
+  throw new Error(
+    `Unknown transport type: "${transport.type}"`
+  );
+}
+
 // src/modes/http.ts
 async function initializeHttpMode(config) {
-  const connectorUrl = config.connectorUrl;
+  const transport = await resolveTransport(
+    config.transport,
+    config.btpUrl,
+    config.connectorUrl,
+    {
+      ...config.managedAnonProxy !== void 0 ? { managedAnonProxy: config.managedAnonProxy } : {},
+      ...config.managedAnonSocksPort !== void 0 ? { managedAnonSocksPort: config.managedAnonSocksPort } : {}
+    }
+  );
+  const effectiveBtpUrl = transport.btpUrl ?? config.btpUrl;
+  const effectiveConnectorUrl = transport.connectorUrl ?? config.connectorUrl;
   const settlementInfo = buildSettlementInfo(config);
+  const discoveredPeer = readDiscoveredIlpPeer({
+    btpEndpoint: effectiveBtpUrl,
+    httpEndpoint: config.connectorHttpEndpoint,
+    supportsUpgrade: config.connectorSupportsUpgrade
+  });
+  const transportChoice = discoveredPeer.httpEndpoint || discoveredPeer.btpEndpoint ? selectIlpTransport(discoveredPeer, { needsDuplex: false }) : null;
   let btpClient = null;
-  if (config.btpUrl) {
+  if (effectiveBtpUrl) {
     btpClient = new BtpRuntimeClient({
-      btpUrl: config.btpUrl,
+      btpUrl: effectiveBtpUrl,
       peerId: config.btpPeerId ?? `client`,
-      authToken: config.btpAuthToken ?? ""
+      authToken: config.btpAuthToken ?? "",
+      createWebSocket: transport.createWebSocket
     });
     await btpClient.connect();
   }
-  const runtimeClient = btpClient ?? new HttpRuntimeClient({
-    connectorUrl,
+  let httpIlpClient = null;
+  if (transportChoice && (transportChoice.kind === "http" || transportChoice.kind === "http-upgradable")) {
+    httpIlpClient = new HttpIlpClient({
+      httpEndpoint: transportChoice.httpEndpoint,
+      ...config.btpPeerId !== void 0 ? { peerId: config.btpPeerId } : {},
+      ...config.btpAuthToken !== void 0 ? { authToken: config.btpAuthToken } : {},
+      timeout: config.queryTimeout,
+      maxRetries: config.maxRetries,
+      retryDelay: config.retryDelay,
+      ...transport.httpClient !== void 0 ? { httpClient: transport.httpClient } : {},
+      ...transport.createWebSocket !== void 0 ? { createWebSocket: transport.createWebSocket } : {}
+    });
+  }
+  const runtimeClient = httpIlpClient ?? btpClient ?? new HttpRuntimeClient({
+    connectorUrl: effectiveConnectorUrl,
     timeout: config.queryTimeout,
     maxRetries: config.maxRetries,
-    retryDelay: config.retryDelay
+    retryDelay: config.retryDelay,
+    httpClient: transport.httpClient
   });
   let onChainChannelClient = null;
   if (config.chainRpcUrls) {
@@ -1517,19 +2844,395 @@ async function initializeHttpMode(config) {
   if (onChainChannelClient) {
     bootstrapService.setChannelClient(onChainChannelClient);
   }
-  const discoveryTracker = createDiscoveryTracker({
-    secretKey: config.secretKey,
-    settlementInfo
-  });
-  return {
-    bootstrapService,
-    discoveryTracker,
-    runtimeClient,
-    adminClient: null,
-    btpClient,
-    onChainChannelClient
-  };
-}
+  const discoveryTracker = createDiscoveryTracker({
+    secretKey: config.secretKey,
+    settlementInfo
+  });
+  return {
+    bootstrapService,
+    discoveryTracker,
+    runtimeClient,
+    adminClient: null,
+    btpClient,
+    onChainChannelClient,
+    // Teardown handle for a managed `anon` proxy this init STARTED (undefined
+    // for explicit-proxy/direct/gateway). ToonClient.stop() invokes it.
+    stopManagedProxy: transport.stopManagedProxy
+  };
+}
+
+// src/signing/solana-signer.ts
+import { ed25519 as ed255193 } from "@noble/curves/ed25519.js";
+import { base58Encode as base58Encode3 } from "@toon-protocol/core";
+var SolanaSigner = class {
+  chainType = "solana";
+  /** 32-byte Ed25519 seed. */
+  privateKey;
+  pubkeyBase58Cache;
+  /**
+   * @param privateKey - 32-byte Ed25519 seed (e.g. `identity.solana.secretKey.slice(0, 32)`).
+   * @param publicKeyBase58 - Optional base58 public key (e.g. `identity.solana.publicKey`).
+   *   When omitted it is derived lazily from `privateKey`.
+   */
+  constructor(privateKey, publicKeyBase58) {
+    if (privateKey.length !== 32) {
+      throw new Error(
+        `SolanaSigner requires a 32-byte Ed25519 seed, got ${privateKey.length} bytes`
+      );
+    }
+    this.privateKey = privateKey;
+    this.pubkeyBase58Cache = publicKeyBase58;
+  }
+  ensurePublicKey() {
+    if (this.pubkeyBase58Cache) return this.pubkeyBase58Cache;
+    const pk = ed255193.getPublicKey(this.privateKey);
+    this.pubkeyBase58Cache = base58Encode3(new Uint8Array(pk));
+    return this.pubkeyBase58Cache;
+  }
+  get signerIdentifier() {
+    return this.pubkeyBase58Cache ?? "uninitialized";
+  }
+  async signBalanceProof(params) {
+    if (params.metadata.chainType !== "solana") {
+      throw new Error(
+        `SolanaSigner cannot sign for chain type: ${params.metadata.chainType}`
+      );
+    }
+    const base58 = this.ensurePublicKey();
+    const message = buildBalanceProofMessage(
+      params.channelId,
+      BigInt(params.nonce),
+      params.transferredAmount
+    );
+    const signature = ed255193.sign(message, this.privateKey);
+    const signatureHex = "0x" + toHex2(new Uint8Array(signature));
+    return {
+      channelId: params.channelId,
+      nonce: params.nonce,
+      transferredAmount: params.transferredAmount,
+      lockedAmount: params.lockedAmount,
+      locksRoot: params.locksRoot,
+      signature: signatureHex,
+      signerAddress: base58,
+      chainId: 0,
+      tokenNetworkAddress: params.metadata.programId,
+      recipient: params.recipient
+    };
+  }
+  buildClaimMessage(proof, senderId) {
+    const sigHex = proof.signature.startsWith("0x") ? proof.signature.slice(2) : proof.signature;
+    const sigBytes = Uint8Array.from(
+      sigHex.match(/.{1,2}/g)?.map((b) => parseInt(b, 16)) ?? []
+    );
+    const signatureBase64 = Buffer.from(sigBytes).toString("base64");
+    const claim = {
+      version: "1.0",
+      blockchain: "solana",
+      messageId: crypto.randomUUID(),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, ".000Z"),
+      senderId,
+      // channelId IS the base58 channel PDA -> connector's channelAccount.
+      channelAccount: proof.channelId,
+      nonce: proof.nonce,
+      transferredAmount: proof.transferredAmount.toString(),
+      signature: signatureBase64,
+      signerPublicKey: this.pubkeyBase58Cache ?? proof.signerAddress,
+      programId: proof.tokenNetworkAddress
+    };
+    return claim;
+  }
+};
+
+// src/signing/mina-signer.ts
+import { hexToMinaBase58PrivateKey as hexToMinaBase58PrivateKey3 } from "@toon-protocol/core";
+import { sha256 as sha2562 } from "@noble/hashes/sha2.js";
+import { bytesToHex } from "@noble/hashes/utils.js";
+
+// src/channel/mina-payment-channel.ts
+var cachedBindings = null;
+async function loadMinaPaymentChannelBindings() {
+  if (cachedBindings) return cachedBindings;
+  const specifier = "mina-signer";
+  const lib = await import(
+    /* @vite-ignore */
+    specifier
+  );
+  const Client = "default" in lib ? lib.default : lib;
+  const resolveFn = import.meta.resolve;
+  let mainUrl;
+  if (typeof resolveFn === "function") {
+    mainUrl = resolveFn(specifier);
+  } else {
+    const { createRequire } = await import("module");
+    const { pathToFileURL } = await import("url");
+    mainUrl = pathToFileURL(
+      createRequire(import.meta.url).resolve(specifier)
+    ).href;
+  }
+  const minaSignerDir = new URL("./", mainUrl);
+  const poseidonUrl = new URL("../bindings/crypto/poseidon.js", minaSignerDir).href;
+  const signatureUrl = new URL("./src/signature.js", minaSignerDir).href;
+  const curveUrl = new URL("./src/curve-bigint.js", minaSignerDir).href;
+  const [poseidonMod, signatureMod, curveMod] = await Promise.all([
+    import(
+      /* @vite-ignore */
+      poseidonUrl
+    ),
+    import(
+      /* @vite-ignore */
+      signatureUrl
+    ),
+    import(
+      /* @vite-ignore */
+      curveUrl
+    )
+  ]);
+  cachedBindings = {
+    Client,
+    Poseidon: poseidonMod.Poseidon,
+    Signature: signatureMod.Signature,
+    PublicKey: curveMod.PublicKey
+  };
+  return cachedBindings;
+}
+function minaBalanceCommitment(poseidon, balanceA, balanceB, salt) {
+  return poseidon.hash([balanceA, balanceB, salt]);
+}
+function minaChannelHashField(poseidon, publicKeyCodec, zkAppAddress) {
+  const zkAppPubKey = publicKeyCodec.fromBase58(zkAppAddress);
+  return poseidon.hash([zkAppPubKey.x]);
+}
+function minaParticipantChannelHashField(poseidon, publicKeyCodec, participantA_B62, participantB_B62, channelNonce) {
+  const a = publicKeyCodec.fromBase58(participantA_B62);
+  const b = publicKeyCodec.fromBase58(participantB_B62);
+  return poseidon.hash([a.x, b.x, channelNonce]);
+}
+async function buildMinaPaymentChannelProof(params) {
+  const { Client, Poseidon, Signature, PublicKey } = await loadMinaPaymentChannelBindings();
+  const client = new Client({ network: "devnet" });
+  const signerPublicKey = params.signerPublicKey ?? client.derivePublicKey(params.minaPrivateKeyBase58);
+  const commitment = minaBalanceCommitment(
+    Poseidon,
+    params.balanceA,
+    params.balanceB,
+    params.salt
+  );
+  const channelHashField = params.participantA && params.participantB ? minaParticipantChannelHashField(
+    Poseidon,
+    PublicKey,
+    params.participantA,
+    params.participantB,
+    params.channelNonce ?? 0n
+  ) : minaChannelHashField(Poseidon, PublicKey, params.zkAppAddress);
+  const message = [commitment, params.nonce, channelHashField];
+  const signed = client.signFields(message, params.minaPrivateKeyBase58);
+  const { r, s } = Signature.fromBase58(signed.signature);
+  const proofObject = {
+    commitment: commitment.toString(),
+    signature: { r: r.toString(), s: s.toString() },
+    nonce: params.nonce.toString(),
+    signerPublicKey
+  };
+  const proofJson = JSON.stringify(proofObject);
+  const encoding = params.proofEncoding ?? "base64";
+  const proof = encoding === "base64" ? Buffer.from(proofJson, "utf8").toString("base64") : proofJson;
+  return {
+    balanceCommitment: commitment.toString(),
+    proof,
+    salt: params.salt.toString(),
+    signerPublicKey
+  };
+}
+
+// src/channel/mina-deposit.ts
+var DEPOSIT_TOTAL_STATE_INDEX = 4;
+async function readMinaDepositTotal(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 BigInt(state[DEPOSIT_TOTAL_STATE_INDEX]);
+}
+
+// src/signing/mina-signer.ts
+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}`))
+  );
+  const salt = BigInt("0x" + digestHex.slice(0, 60));
+  return salt === 0n ? 1n : salt;
+}
+var MinaSigner = class {
+  chainType = "mina";
+  /** Big-endian hex scalar (or already-`EK…` base58) Mina private key. */
+  privateKey;
+  publicKeyBase58;
+  depositReader;
+  /** Per-zkApp `depositTotal` cache (deposits are rare; the connector re-reads). */
+  depositCache = /* @__PURE__ */ new Map();
+  /**
+   * @param privateKey - Mina private key as big-endian hex scalar (the form
+   *   `deriveFullIdentity()` emits, `identity.mina.privateKey`) or an `EK…`
+   *   base58 key. Converted to the base58check form mina-signer requires.
+   * @param publicKeyBase58 - Optional base58 public key (e.g.
+   *   `identity.mina.publicKey`). When omitted it is derived during signing.
+   * @param options - Optional on-chain `depositTotal` resolution (graphqlUrl or
+   *   an injected reader) so claims conserve balances on funded zkApps.
+   */
+  constructor(privateKey, publicKeyBase58, options) {
+    this.privateKey = privateKey;
+    this.publicKeyBase58 = publicKeyBase58;
+    if (options?.depositReader) {
+      this.depositReader = options.depositReader;
+    } else if (options?.graphqlUrl) {
+      const url = options.graphqlUrl;
+      this.depositReader = (zkAppAddress) => readMinaDepositTotal(url, zkAppAddress);
+    }
+  }
+  /**
+   * Resolve the channel's on-chain `depositTotal`, caching per zkApp. Returns
+   * `undefined` when no reader is configured or the read fails — callers then
+   * fall back to the legacy `balanceB = 0` commitment.
+   */
+  async resolveDepositTotal(zkAppAddress) {
+    if (this.depositCache.has(zkAppAddress)) {
+      return this.depositCache.get(zkAppAddress);
+    }
+    if (!this.depositReader) return void 0;
+    try {
+      const depositTotal = await this.depositReader(zkAppAddress);
+      this.depositCache.set(zkAppAddress, depositTotal);
+      return depositTotal;
+    } catch {
+      return void 0;
+    }
+  }
+  get signerIdentifier() {
+    return this.publicKeyBase58 ?? "uninitialized";
+  }
+  /** Derive this signer's B62 public key from its (base58) private key. */
+  async deriveOwnPublicKey(minaPrivateKeyBase58) {
+    const { Client } = await loadMinaPaymentChannelBindings();
+    return new Client({ network: MINA_CLAIM_NETWORK }).derivePublicKey(
+      minaPrivateKeyBase58
+    );
+  }
+  async signBalanceProof(params) {
+    if (params.metadata.chainType !== "mina") {
+      throw new Error(
+        `MinaSigner cannot sign for chain type: ${params.metadata.chainType}`
+      );
+    }
+    const zkAppAddress = params.channelId || params.metadata.zkAppAddress;
+    if (!zkAppAddress) {
+      throw new Error(
+        "MinaSigner requires a zkAppAddress (channel id) to sign a balance proof"
+      );
+    }
+    const minaPrivateKey = hexToMinaBase58PrivateKey3(this.privateKey);
+    const tokenId = params.metadata.tokenId ?? DEFAULT_MINA_TOKEN_ID;
+    const salt = deriveMinaSalt(zkAppAddress, params.nonce);
+    const clientPubKey = this.publicKeyBase58 ?? await this.deriveOwnPublicKey(minaPrivateKey);
+    this.publicKeyBase58 = clientPubKey;
+    const apexPubKey = params.recipient && /^B62[a-zA-Z0-9]{40,60}$/.test(params.recipient) ? params.recipient : void 0;
+    const depositTotal = params.depositTotal ?? await this.resolveDepositTotal(zkAppAddress);
+    let balanceB = 0n;
+    if (depositTotal != null && depositTotal > 0n) {
+      if (params.transferredAmount > depositTotal) {
+        throw new Error(
+          `Mina claim balanceA (${params.transferredAmount}) exceeds on-chain depositTotal (${depositTotal}) \u2014 cannot conserve balances`
+        );
+      }
+      balanceB = depositTotal - params.transferredAmount;
+    }
+    const built = await buildMinaPaymentChannelProof({
+      zkAppAddress,
+      minaPrivateKeyBase58: minaPrivateKey,
+      signerPublicKey: clientPubKey,
+      // Recipient-credit (unidirectional): party A carries the cumulative amount;
+      // party B carries the funder's remaining balance (depositTotal − balanceA)
+      // so the signed commitment conserves and the on-chain claimFromChannel
+      // signatureA check passes. `signatureB` remains apex-co-signed downstream.
+      balanceA: params.transferredAmount,
+      balanceB,
+      salt,
+      nonce: BigInt(params.nonce),
+      // Participant-form channelHash (on-chain-settleable) when the apex pubkey
+      // is known; otherwise the legacy zkApp-x form (off-chain-store only).
+      ...apexPubKey ? { participantA: clientPubKey, participantB: apexPubKey } : {}
+    });
+    this.publicKeyBase58 = built.signerPublicKey;
+    return {
+      channelId: zkAppAddress,
+      nonce: params.nonce,
+      transferredAmount: params.transferredAmount,
+      lockedAmount: params.lockedAmount,
+      locksRoot: params.locksRoot,
+      // `signature` is unused on the Mina wire (the proof carries the Schnorr
+      // signature); keep the base64 proof here too for symmetry / debugging.
+      signature: built.proof,
+      signerAddress: built.signerPublicKey,
+      chainId: 0,
+      tokenNetworkAddress: zkAppAddress,
+      recipient: params.recipient,
+      mina: {
+        balanceCommitment: built.balanceCommitment,
+        proof: built.proof,
+        salt: built.salt,
+        tokenId
+      }
+    };
+  }
+  buildClaimMessage(proof, senderId) {
+    if (!proof.mina) {
+      throw new Error(
+        "MinaSigner.buildClaimMessage requires a Mina-signed proof (missing `mina` fields)"
+      );
+    }
+    const claim = {
+      version: "1.0",
+      blockchain: "mina",
+      messageId: crypto.randomUUID(),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, ".000Z"),
+      senderId,
+      zkAppAddress: proof.channelId,
+      tokenId: proof.mina.tokenId,
+      balanceCommitment: proof.mina.balanceCommitment,
+      nonce: proof.nonce,
+      proof: proof.mina.proof,
+      salt: proof.mina.salt,
+      transferredAmount: proof.transferredAmount.toString(),
+      // Surface the signer's Mina pubkey top-level (it is also embedded in the
+      // base64 `proof`). The connector's SettlementExecutor reads
+      // `latestClaim.signerPublicKey` to resolve participant keys for the
+      // on-chain claimFromChannel on an inbound/externally-opened channel;
+      // without it the Mina SDK throws ACCOUNT_NOT_FOUND. `signerAddress`
+      // carries the B62 base58 pubkey for Mina proofs (see MinaSigner.sign*).
+      signerPublicKey: proof.signerAddress,
+      network: MINA_CLAIM_NETWORK
+    };
+    return claim;
+  }
+};
 
 // src/channel/ChannelManager.ts
 var ChannelManager = class {
@@ -1629,7 +3332,11 @@ var ChannelManager = class {
           chainType: negotiation.chainType,
           chainId: typeof negotiation.chainId === "number" ? negotiation.chainId : 0,
           tokenNetworkAddress: negotiation.tokenNetwork ?? "",
-          tokenAddress: negotiation.tokenAddress
+          tokenAddress: negotiation.tokenAddress,
+          recipient: negotiation.settlementAddress,
+          // On-chain depositTotal (Mina only) — needed so the Mina signer binds
+          // balanceB = depositTotal − balanceA (connector#133).
+          depositTotal: result.depositTotal
         });
         this.peerChannels.set(peerId, result.channelId);
         return result.channelId;
@@ -1667,7 +3374,9 @@ var ChannelManager = class {
           chainType: chainContext?.chainType ?? "evm",
           chainId: cId,
           tokenNetworkAddress: tnAddr,
-          tokenAddress: chainContext?.tokenAddress
+          tokenAddress: chainContext?.tokenAddress,
+          recipient: chainContext?.recipient,
+          depositTotal: chainContext?.depositTotal
         });
         return;
       }
@@ -1678,7 +3387,9 @@ var ChannelManager = class {
       chainType: chainContext?.chainType ?? "evm",
       chainId: cId,
       tokenNetworkAddress: tnAddr,
-      tokenAddress: chainContext?.tokenAddress
+      tokenAddress: chainContext?.tokenAddress,
+      recipient: chainContext?.recipient,
+      depositTotal: chainContext?.depositTotal
     });
   }
   /**
@@ -1708,6 +3419,11 @@ var ChannelManager = class {
     }
     const signer = this.chainSigners.get(tracking.chainType);
     if (signer && tracking.chainType !== "evm") {
+      if (!tracking.recipient) {
+        throw new Error(
+          `Channel "${channelId}" (${tracking.chainType}) has no recipient settlement address; cannot sign a Solana/Mina balance proof. Ensure the peer negotiation supplied a settlementAddress.`
+        );
+      }
       const metadata = this.buildMetadata(tracking);
       return signer.signBalanceProof({
         channelId,
@@ -1715,7 +3431,13 @@ var ChannelManager = class {
         transferredAmount: tracking.cumulativeAmount,
         lockedAmount: 0n,
         locksRoot: "0x0000000000000000000000000000000000000000000000000000000000000000",
-        metadata
+        recipient: tracking.recipient,
+        metadata,
+        // On-chain depositTotal captured at open time (#220) — the Mina signer
+        // binds balanceB = depositTotal − balanceA (connector#133); the Solana
+        // signer ignores it. When undefined (resume / idempotent re-open) the
+        // Mina signer self-resolves it from chain (#223).
+        depositTotal: tracking.depositTotal
       });
     }
     if (!this.evmSigner) {
@@ -1828,11 +3550,91 @@ var JsonFileChannelStore = class {
   }
 };
 
+// src/blob-storage.ts
+import { buildBlobStorageRequest } from "@toon-protocol/core";
+var ARWEAVE_TX_ID_REGEX = /^[A-Za-z0-9_-]{43}$/;
+async function requestBlobStorage(client, secretKey, params) {
+  const bid = params.bid ?? (params.ilpAmount !== void 0 ? String(params.ilpAmount) : void 0);
+  if (bid === void 0 || bid === "") {
+    return {
+      success: false,
+      error: "requestBlobStorage requires a bid (or ilpAmount to derive it)"
+    };
+  }
+  const blobBuffer = Buffer.from(
+    params.blobData.buffer,
+    params.blobData.byteOffset,
+    params.blobData.byteLength
+  );
+  let event;
+  try {
+    event = buildBlobStorageRequest(
+      {
+        blobData: blobBuffer,
+        contentType: params.contentType,
+        bid
+      },
+      secretKey
+    );
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+  const result = await client.publishEvent(event, {
+    destination: params.destination,
+    claim: params.claim,
+    ilpAmount: params.ilpAmount
+  });
+  if (!result.success) {
+    return {
+      success: false,
+      eventId: result.eventId ?? event.id,
+      error: result.error ?? "Blob storage request rejected"
+    };
+  }
+  if (!result.data) {
+    return {
+      success: false,
+      eventId: event.id,
+      error: "FULFILL contained no data; expected base64-encoded Arweave tx ID"
+    };
+  }
+  const txId = decodeUtf8(fromBase64(result.data));
+  if (!ARWEAVE_TX_ID_REGEX.test(txId)) {
+    return {
+      success: false,
+      eventId: event.id,
+      error: `Decoded FULFILL data is not a valid Arweave tx ID: "${txId}"`
+    };
+  }
+  return {
+    success: true,
+    txId,
+    eventId: event.id
+  };
+}
+
 // src/ToonClient.ts
 var ToonClient = class {
   config;
   state = null;
   evmSigner;
+  solanaSigner;
+  /**
+   * Ed25519 signing seed (32 bytes) derived from the mnemonic for the Solana
+   * identity. Retained so `start()` can inject it into the on-chain channel
+   * client's Solana config (same key as `solanaSigner`).
+   */
+  solanaSeed;
+  minaSigner;
+  /**
+   * Mina private key (big-endian hex scalar, as `deriveFullIdentity` emits)
+   * derived from the mnemonic. Retained so `start()` can inject it into the
+   * on-chain channel client's Mina config (same key as `minaSigner`).
+   */
+  minaPrivateKey;
   channelManager;
   peerNegotiations = /* @__PURE__ */ new Map();
   /**
@@ -1854,8 +3656,8 @@ var ToonClient = class {
    * @returns Object with secretKey (Uint8Array) and pubkey (hex string)
    */
   static generateKeypair() {
-    const secretKey = generateSecretKey2();
-    const pubkey = getPublicKey(secretKey);
+    const secretKey = generateSecretKey3();
+    const pubkey = getPublicKey2(secretKey);
     return { secretKey, pubkey };
   }
   /**
@@ -1863,7 +3665,37 @@ var ToonClient = class {
    * Works before start() is called.
    */
   getPublicKey() {
-    return getPublicKey(this.config.secretKey);
+    return getPublicKey2(this.config.secretKey);
+  }
+  /**
+   * Sign an unsigned Nostr event template with the client's Nostr secret key,
+   * returning a fully-signed event (id + pubkey + sig).
+   *
+   * This is the key primitive behind the daemon's sign-and-publish path: a UI
+   * or agent supplies only `{ kind, content, tags, created_at }` and never holds
+   * the private key — signing happens here, inside the key owner.
+   */
+  signEvent(template) {
+    return finalizeEvent(template, this.config.secretKey);
+  }
+  /**
+   * Upload bytes to Arweave via the kind:5094 blob-storage DVM (single-packet),
+   * signing the request with this client's Nostr key and paying through its
+   * existing channel. Returns the Arweave tx id on success.
+   *
+   * Backs the daemon's `upload-media` path: the key and claim/channel plumbing
+   * stay inside the client; callers pass only the bytes.
+   */
+  async uploadBlob(params) {
+    return requestBlobStorage(this, this.config.secretKey, params);
+  }
+  /**
+   * Per-chain settlement readiness for the configured `network` tier, mirroring
+   * the townhouse node's status. Returns `undefined` when no named `network` is
+   * set (or `network: 'custom'`), since there is no preset tier to report on.
+   */
+  getNetworkStatus() {
+    return getNetworkStatus(this.config);
   }
   /**
    * Gets the EVM address derived from the Nostr secret key (or explicit evmPrivateKey override).
@@ -1871,6 +3703,46 @@ var ToonClient = class {
   getEvmAddress() {
     return this.evmSigner?.address;
   }
+  /**
+   * Gets the Solana (base58) address, when the client was constructed from a
+   * `mnemonic`. Available only AFTER `start()` (Solana keys are derived
+   * asynchronously). Returns undefined otherwise.
+   */
+  getSolanaAddress() {
+    return this.solanaSigner?.signerIdentifier;
+  }
+  /**
+   * Gets the Mina (base58) address, when the client was constructed from a
+   * `mnemonic` AND `mina-signer` is installed. Available only AFTER `start()`.
+   * Returns undefined otherwise.
+   */
+  getMinaAddress() {
+    return this.minaSigner?.signerIdentifier;
+  }
+  /**
+   * Derive the Solana/Mina keys from the mnemonic and register their signers on
+   * the ChannelManager. Mirrors how the EVM signer is wired, but for the
+   * non-secp256k1 chains. Skips any chain whose optional dependency is missing.
+   */
+  async registerMnemonicChainSigners(mnemonic, accountIndex = 0) {
+    if (!this.channelManager) return;
+    const identity = await deriveFullIdentity(mnemonic, accountIndex);
+    if (identity.solana.publicKey) {
+      const seed = identity.solana.secretKey.slice(0, 32);
+      this.solanaSeed = seed;
+      this.solanaSigner = new SolanaSigner(seed, identity.solana.publicKey);
+      this.channelManager.registerChainSigner("solana", this.solanaSigner);
+    }
+    if (identity.mina.publicKey) {
+      this.minaPrivateKey = identity.mina.privateKey;
+      this.minaSigner = new MinaSigner(
+        identity.mina.privateKey,
+        identity.mina.publicKey,
+        this.config.minaChannel?.graphqlUrl ? { graphqlUrl: this.config.minaChannel.graphqlUrl } : void 0
+      );
+      this.channelManager.registerChainSigner("mina", this.minaSigner);
+    }
+  }
   /**
    * Starts the ToonClient.
    *
@@ -1891,9 +3763,21 @@ var ToonClient = class {
       if (this.evmSigner) {
         const store = this.config.channelStorePath ? new JsonFileChannelStore(this.config.channelStorePath) : void 0;
         this.channelManager = new ChannelManager(this.evmSigner, store);
+        if (this.config.mnemonic) {
+          await this.registerMnemonicChainSigners(
+            this.config.mnemonic,
+            this.config.mnemonicAccountIndex ?? 0
+          );
+        }
       }
       const initialization = await initializeHttpMode(this.config);
-      const { bootstrapService, discoveryTracker, runtimeClient, btpClient } = initialization;
+      const {
+        bootstrapService,
+        discoveryTracker,
+        runtimeClient,
+        btpClient,
+        stopManagedProxy
+      } = initialization;
       if (this.channelManager) {
         const cm = this.channelManager;
         const nostrPubkey = this.getPublicKey();
@@ -1904,7 +3788,8 @@ var ToonClient = class {
               cm.trackChannel(channelId, defaultChainCtx);
             }
             const proof = await cm.signBalanceProof(channelId, amount);
-            return EvmSigner.buildClaimMessage(proof, nostrPubkey);
+            const signer = cm.getSignerForChannel(channelId);
+            return signer.buildClaimMessage(proof, nostrPubkey);
           }
         );
       }
@@ -1953,13 +3838,35 @@ var ToonClient = class {
         this.channelManager.setChannelClient(
           initialization.onChainChannelClient
         );
+        if (this.config.solanaChannel && this.solanaSeed) {
+          initialization.onChainChannelClient.setSolanaConfig({
+            rpcUrl: this.config.solanaChannel.rpcUrl,
+            programId: this.config.solanaChannel.programId,
+            tokenMint: this.config.solanaChannel.tokenMint,
+            challengeDuration: this.config.solanaChannel.challengeDuration,
+            deposit: this.config.solanaChannel.deposit,
+            keypair: this.solanaSeed
+          });
+        }
+        if (this.config.minaChannel && this.minaPrivateKey) {
+          initialization.onChainChannelClient.setMinaConfig({
+            graphqlUrl: this.config.minaChannel.graphqlUrl,
+            zkAppAddress: this.config.minaChannel.zkAppAddress,
+            privateKey: this.minaPrivateKey,
+            ...this.config.minaChannel.challengeDuration !== void 0 ? { challengeDuration: this.config.minaChannel.challengeDuration } : {},
+            ...this.config.minaChannel.tokenId !== void 0 ? { tokenId: this.config.minaChannel.tokenId } : {},
+            ...this.config.minaChannel.deposit !== void 0 ? { deposit: this.config.minaChannel.deposit } : {},
+            ...this.config.minaChannel.networkId !== void 0 ? { networkId: this.config.minaChannel.networkId } : {}
+          });
+        }
       }
       this.state = {
         bootstrapService,
         discoveryTracker,
         runtimeClient,
         peersDiscovered: bootstrapResults.length,
-        btpClient: btpClient ?? void 0
+        btpClient: btpClient ?? void 0,
+        ...stopManagedProxy ? { stopManagedProxy } : {}
       };
       return {
         peersDiscovered: bootstrapResults.length,
@@ -1994,7 +3901,7 @@ var ToonClient = class {
     try {
       const toonData = this.config.toonEncoder(event);
       const basePricePerByte = 10n;
-      const amount = String(BigInt(toonData.length) * basePricePerByte);
+      const amount = options?.ilpAmount !== void 0 ? String(options.ilpAmount) : String(BigInt(toonData.length) * basePricePerByte);
       const destination = options?.destination ?? this.config.destinationAddress;
       if (!this.state.btpClient) {
         throw new ToonClientError(
@@ -2004,10 +3911,7 @@ var ToonClient = class {
       }
       let claimMessage;
       if (options?.claim) {
-        claimMessage = EvmSigner.buildClaimMessage(
-          options.claim,
-          this.getPublicKey()
-        );
+        claimMessage = this.buildClaimMessageForProof(options.claim);
       } else if (this.channelManager) {
         const peerId = this.resolvePeerId(destination);
         const negotiation = this.peerNegotiations.get(peerId);
@@ -2067,6 +3971,112 @@ var ToonClient = class {
       );
     }
   }
+  /**
+   * Sends a raw swap ILP packet (Story 12.5) to a Mill peer with an attached
+   * balance-proof claim. This is a lower-level surface than `publishEvent`:
+   * it forwards the raw `IlpSendResult` so the sender (`streamSwap()`) can
+   * decode FULFILL metadata itself.
+   *
+   * Claim resolution mirrors `publishEvent`:
+   *   (a) explicit `params.claim` -> use it,
+   *   (b) `channelManager` present -> auto-open + auto-sign for the peer
+   *       matching `destination`,
+   *   (c) neither -> throw MISSING_CLAIM.
+   *
+   * @throws {ToonClientError} INVALID_STATE / NO_BTP_CLIENT / MISSING_CLAIM
+   */
+  async sendSwapPacket(params) {
+    if (!this.state) {
+      throw new ToonClientError(
+        "Client not started. Call start() first.",
+        "INVALID_STATE"
+      );
+    }
+    if (!this.state.btpClient) {
+      throw new ToonClientError(
+        "BTP client required for sending swap packets. Configure btpUrl.",
+        "NO_BTP_CLIENT"
+      );
+    }
+    const claimMessage = await this.resolveClaimForDestination(
+      params.destination,
+      params.amount,
+      params.claim
+    );
+    return this.state.btpClient.sendIlpPacketWithClaim(
+      {
+        destination: params.destination,
+        amount: String(params.amount),
+        data: toBase64(params.toonData),
+        timeout: params.timeout ?? 3e4
+      },
+      claimMessage
+    );
+  }
+  /**
+   * Build a BTP claim message from a pre-signed balance proof using the
+   * CHAIN-APPROPRIATE signer.
+   *
+   * The explicit-claim path (caller signs the balance proof, then passes
+   * `{ claim }`) must wrap the proof with the signer matching the channel's
+   * chain. Hardcoding `EvmSigner.buildClaimMessage` here produced an EVM
+   * `BTPClaimMessage` for a Solana/Mina balance proof — no `blockchain`
+   * discriminator and the base58 channel account placed in the EVM
+   * `channelId` field — which the connector's inbound validator classifies
+   * as EVM and rejects with F06 (`Invalid channelId format`).
+   *
+   * When the proof's `channelId` is tracked we use
+   * `getSignerForChannel(channelId).buildClaimMessage`, which emits the
+   * correct per-chain envelope (e.g. `blockchain:'solana'` + base58
+   * `channelAccount`). When it is not tracked we fall back to the EVM signer
+   * to preserve prior behavior for lightweight/EVM-only callers.
+   *
+   * EVM output is byte-identical to the previous hardcoded path (the EVM
+   * adapter in `getSignerForChannel` delegates to the same
+   * `EvmSigner.buildClaimMessage`).
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any -- claim message is opaque forwarded type
+  buildClaimMessageForProof(claim) {
+    if (this.channelManager?.isTracking(claim.channelId)) {
+      const signer = this.channelManager.getSignerForChannel(claim.channelId);
+      return signer.buildClaimMessage(claim, this.getPublicKey());
+    }
+    return EvmSigner.buildClaimMessage(claim, this.getPublicKey());
+  }
+  /**
+   * 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) {
+      return this.buildClaimMessageForProof(explicitClaim);
+    }
+    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,
+        amount
+      );
+      const signer = this.channelManager.getSignerForChannel(channelId);
+      return signer.buildClaimMessage(proof, this.getPublicKey());
+    }
+    throw new ToonClientError(
+      "No claim provided and no channel manager configured",
+      "MISSING_CLAIM"
+    );
+  }
   /**
    * Signs a balance proof for the given channel with the specified amount.
    * Delegates to ChannelManager which auto-increments nonce and tracks cumulative amount.
@@ -2085,6 +4095,51 @@ var ToonClient = class {
     }
     return this.channelManager.signBalanceProof(channelId, amount);
   }
+  /**
+   * Eagerly open (or return existing) payment channel for the given destination.
+   *
+   * Channels are normally opened lazily on the first `publishEvent()` /
+   * `sendSwapPacket()` call. This method exposes the lazy-open path so
+   * callers (and E2E tests) that need a tracked `channelId` BEFORE publishing
+   * can force the open. Idempotent — returns the existing channel ID for the
+   * peer if one is already open.
+   *
+   * @param destination - Optional ILP destination address. Defaults to
+   *   `config.destinationAddress`.
+   * @returns The channel ID of the (now) open channel.
+   * @throws {ToonClientError} If client not started, no channel manager
+   *   configured, or peer negotiation metadata missing.
+   */
+  async openChannel(destination) {
+    if (!this.state) {
+      throw new ToonClientError(
+        "Client not started. Call start() first.",
+        "INVALID_STATE"
+      );
+    }
+    if (!this.channelManager) {
+      throw new ToonClientError(
+        "No channel manager configured. Provide evmPrivateKey in config.",
+        "NO_EVM_SIGNER"
+      );
+    }
+    const dest = destination ?? this.config.destinationAddress;
+    if (!dest) {
+      throw new ToonClientError(
+        "No destination provided and no default destinationAddress configured.",
+        "NO_DESTINATION"
+      );
+    }
+    const peerId = this.resolvePeerId(dest);
+    const negotiation = this.peerNegotiations.get(peerId);
+    if (!negotiation) {
+      throw new ToonClientError(
+        `No negotiation metadata for peer "${peerId}" \u2014 was bootstrap completed?`,
+        "PEER_NOT_NEGOTIATED"
+      );
+    }
+    return this.channelManager.ensureChannel(peerId, negotiation);
+  }
   /**
    * Gets list of tracked payment channel IDs.
    */
@@ -2182,10 +4237,7 @@ var ToonClient = class {
         "NO_BTP_CLIENT"
       );
     }
-    const claimMessage = EvmSigner.buildClaimMessage(
-      params.claim,
-      this.getPublicKey()
-    );
+    const claimMessage = this.buildClaimMessageForProof(params.claim);
     return this.state.btpClient.sendIlpPacketWithClaim(
       ilpParams,
       claimMessage
@@ -2204,10 +4256,14 @@ var ToonClient = class {
     if (!this.state) {
       throw new ToonClientError("Client not started", "INVALID_STATE");
     }
+    const stopManagedProxy = this.state.stopManagedProxy;
     try {
       if (this.state.btpClient) {
         await this.state.btpClient.disconnect();
       }
+      if (stopManagedProxy) {
+        await stopManagedProxy();
+      }
       this.state = null;
     } catch (error) {
       throw new ToonClientError(
@@ -2255,6 +4311,26 @@ var ToonClient = class {
   }
 };
 
+// src/transport/hs-hostname.ts
+var HS_HOSTNAME_REGEX = /^[a-z2-7]+\.anyone$/;
+var HS_HOSTNAME_MAX_LENGTH = 80;
+function isRoutableHsHostname(s) {
+  return typeof s === "string" && s.length <= HS_HOSTNAME_MAX_LENGTH && HS_HOSTNAME_REGEX.test(s);
+}
+function assertRoutableHsHostname(hostname) {
+  if (typeof hostname === "string" && /\.anon$/.test(hostname)) {
+    throw new Error(
+      `"${hostname}" is not a routable hidden-service address; use the .anyone TLD (e.g. "${hostname.replace(/\.anon$/, ".anyone")}"). The anon daemon only resolves hidden services under .anyone \u2014 a .anon name is treated as a clearnet address and fails (HostUnreachable).`
+    );
+  }
+  if (!isRoutableHsHostname(hostname)) {
+    throw new Error(
+      `Invalid hidden-service hostname: ${JSON.stringify(hostname)}. Expected a base32 .anyone address matching ${HS_HOSTNAME_REGEX}.`
+    );
+  }
+  return hostname;
+}
+
 // src/adapters/HttpConnectorAdmin.ts
 var HttpConnectorAdmin = class {
   adminUrl;
@@ -2551,324 +4627,452 @@ var HttpConnectorAdmin = class {
         throw new PeerAlreadyExistsError(
           `Peer already exists: "${peerId}" (${endpoint}): ${statusText}${errorMessage}`
         );
-      default:
-        if (status >= 500) {
-          throw new ConnectorError(
-            `Connector admin API error (${endpoint}): ${status} ${statusText}${errorMessage}`
-          );
-        }
-        throw new ConnectorError(
-          `Admin API error (${endpoint}): ${status} ${statusText}${errorMessage}`
-        );
-    }
-  }
-};
-
-// src/signing/solana-signer.ts
-var BASE58_ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
-function toBase58(bytes) {
-  let num = BigInt(0);
-  for (const b of bytes) num = num * 256n + BigInt(b);
-  let result = "";
-  while (num > 0n) {
-    result = BASE58_ALPHABET[Number(num % 58n)] + result;
-    num = num / 58n;
-  }
-  for (const b of bytes) {
-    if (b === 0) result = "1" + result;
-    else break;
-  }
-  return result;
-}
-var _ed25519 = null;
-async function getEd25519() {
-  if (!_ed25519) {
-    const mod = await import("@noble/curves/ed25519");
-    _ed25519 = mod.ed25519;
-  }
-  return _ed25519;
-}
-var SolanaSigner = class {
-  chainType = "solana";
-  privateKey;
-  publicKey;
-  pubkeyBase58Cache;
-  constructor(privateKey) {
-    this.privateKey = privateKey;
-  }
-  async ensurePublicKey() {
-    if (this.publicKey && this.pubkeyBase58Cache) {
-      return { publicKey: this.publicKey, base58: this.pubkeyBase58Cache };
-    }
-    const ed = await getEd25519();
-    const pk = ed.getPublicKey(this.privateKey);
-    const b58 = toBase58(pk);
-    this.publicKey = pk;
-    this.pubkeyBase58Cache = b58;
-    return { publicKey: pk, base58: b58 };
-  }
-  get signerIdentifier() {
-    return this.pubkeyBase58Cache ?? "uninitialized";
-  }
-  async signBalanceProof(params) {
-    if (params.metadata.chainType !== "solana") {
-      throw new Error(
-        `SolanaSigner cannot sign for chain type: ${params.metadata.chainType}`
-      );
-    }
-    const ed = await getEd25519();
-    const { base58 } = await this.ensurePublicKey();
-    const encoder = new TextEncoder();
-    const message = encoder.encode(
-      `${params.channelId}:${params.nonce}:${params.transferredAmount}:${params.lockedAmount}:${params.locksRoot}`
-    );
-    const signature = ed.sign(message, this.privateKey);
-    const signatureHex = "0x" + toHex(new Uint8Array(signature));
-    return {
-      channelId: params.channelId,
-      nonce: params.nonce,
-      transferredAmount: params.transferredAmount,
-      lockedAmount: params.lockedAmount,
-      locksRoot: params.locksRoot,
-      signature: signatureHex,
-      signerAddress: base58,
-      chainId: 0,
-      tokenNetworkAddress: params.metadata.programId
-    };
-  }
-  buildClaimMessage(proof, senderId) {
-    const claim = {
-      version: "1.0",
-      blockchain: "solana",
-      messageId: crypto.randomUUID(),
-      timestamp: (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, ".000Z"),
-      senderId,
-      channelId: proof.channelId,
-      nonce: proof.nonce,
-      transferredAmount: proof.transferredAmount.toString(),
-      signature: proof.signature,
-      signerAddress: this.pubkeyBase58Cache ?? proof.signerAddress,
-      programId: proof.tokenNetworkAddress
-    };
-    return claim;
+      default:
+        if (status >= 500) {
+          throw new ConnectorError(
+            `Connector admin API error (${endpoint}): ${status} ${statusText}${errorMessage}`
+          );
+        }
+        throw new ConnectorError(
+          `Admin API error (${endpoint}): ${status} ${statusText}${errorMessage}`
+        );
+    }
   }
 };
 
-// src/signing/mina-signer.ts
-var MinaSigner = class {
-  chainType = "mina";
-  privateKeyBase58;
-  publicKeyBase58 = "uninitialized";
-  constructor(privateKeyBase58) {
-    this.privateKeyBase58 = privateKeyBase58;
-  }
-  get signerIdentifier() {
-    return this.publicKeyBase58;
+// src/pet/filterPetDvmProviders.ts
+import { parseServiceDiscovery } from "@toon-protocol/core";
+import { PET_INTERACTION_REQUEST_KIND } from "@toon-protocol/core";
+function filterPetDvmProviders(events) {
+  const providers = [];
+  for (const event of events) {
+    let parsed;
+    try {
+      parsed = parseServiceDiscovery(event);
+    } catch {
+      continue;
+    }
+    if (!parsed) continue;
+    const skill = parsed.skill;
+    if (!skill) continue;
+    if (!skill.kinds.includes(PET_INTERACTION_REQUEST_KIND)) continue;
+    const pricing = skill.pricing[String(PET_INTERACTION_REQUEST_KIND)] ?? "0";
+    providers.push({
+      ilpAddress: parsed.ilpAddress,
+      pricing,
+      pubkey: event.pubkey,
+      features: skill.features
+    });
   }
-  async ensurePublicKey() {
-    if (this.publicKeyBase58 !== "uninitialized") return this.publicKeyBase58;
-    const o1js = await import("o1js");
-    const pk = o1js.PrivateKey.fromBase58(this.privateKeyBase58);
-    this.publicKeyBase58 = pk.toPublicKey().toBase58();
-    return this.publicKeyBase58;
+  providers.sort((a, b) => {
+    const priceA = Number(a.pricing) || 0;
+    const priceB = Number(b.pricing) || 0;
+    return priceA - priceB;
+  });
+  return providers;
+}
+
+// src/pet/buildPetInteractionRequest.ts
+import { PET_INTERACTION_REQUEST_KIND as PET_INTERACTION_REQUEST_KIND2 } from "@toon-protocol/core";
+var MAX_ACTION_TYPE = 10;
+function buildPetInteractionRequest(params) {
+  const { blobbiId, actionType, itemId, tokenCost, isSleeping } = params;
+  if (!blobbiId || blobbiId.trim() === "") {
+    throw new ValidationError("blobbiId must be a non-empty string");
+  }
+  if (!Number.isInteger(actionType) || actionType < 0 || actionType > MAX_ACTION_TYPE) {
+    throw new ValidationError(
+      `actionType must be an integer between 0 and ${MAX_ACTION_TYPE}, got ${actionType}`
+    );
   }
-  async signBalanceProof(params) {
-    if (params.metadata.chainType !== "mina") {
-      throw new Error(
-        `MinaSigner cannot sign for chain type: ${params.metadata.chainType}`
-      );
-    }
-    const o1js = await import("o1js");
-    const pubkey = await this.ensurePublicKey();
-    const channelIdNum = BigInt(
-      "0x" + params.channelId.replace(/^0x/, "").slice(0, 16)
+  if (!Number.isInteger(itemId) || itemId < 0) {
+    throw new ValidationError(
+      `itemId must be a non-negative integer, got ${itemId}`
     );
-    const commitment = o1js.Poseidon.hash([
-      o1js.Field(channelIdNum),
-      o1js.Field(params.nonce),
-      o1js.Field(params.transferredAmount),
-      o1js.Field(params.lockedAmount)
-    ]);
-    const pk = o1js.PrivateKey.fromBase58(this.privateKeyBase58);
-    const signature = o1js.Signature.create(pk, [commitment]);
-    return {
-      channelId: params.channelId,
-      nonce: params.nonce,
-      transferredAmount: params.transferredAmount,
-      lockedAmount: params.lockedAmount,
-      locksRoot: params.locksRoot,
-      signature: signature.toBase58(),
-      signerAddress: pubkey,
-      chainId: 0,
-      tokenNetworkAddress: params.metadata.zkAppAddress
-    };
   }
-  buildClaimMessage(proof, senderId) {
-    const claim = {
-      version: "1.0",
-      blockchain: "mina",
-      messageId: crypto.randomUUID(),
-      timestamp: (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, ".000Z"),
-      senderId,
-      channelId: proof.channelId,
-      nonce: proof.nonce,
-      transferredAmount: proof.transferredAmount.toString(),
-      commitment: proof.signature,
-      signerAddress: proof.signerAddress,
-      zkAppAddress: proof.tokenNetworkAddress
-    };
-    return claim;
+  if (!Number.isFinite(tokenCost) || tokenCost < 0) {
+    throw new ValidationError(
+      `tokenCost must be a non-negative number, got ${tokenCost}`
+    );
   }
-};
-
-// src/keys/KeyManager.ts
-import { finalizeEvent } from "nostr-tools/pure";
-import { nip19 } from "nostr-tools";
-
-// src/keys/KeyDerivation.ts
-import { generateSecretKey as generateSecretKey3, getPublicKey as getPublicKey2 } from "nostr-tools/pure";
-import { privateKeyToAccount as privateKeyToAccount2 } from "viem/accounts";
-import { toHex as toHex3 } from "viem";
-import {
-  generateMnemonic as _genMnemonic,
-  validateMnemonic as _validateMnemonic,
-  mnemonicToSeedSync
-} from "@scure/bip39";
-import { wordlist as english } from "@scure/bip39/wordlists/english";
-import { HDKey } from "@scure/bip32";
-function generateMnemonic() {
-  return _genMnemonic(english, 128);
+  return {
+    kind: PET_INTERACTION_REQUEST_KIND2,
+    created_at: Math.floor(Date.now() / 1e3),
+    tags: [
+      ["d", blobbiId],
+      ["action", String(actionType)],
+      ["item", String(itemId)],
+      ["cost", String(tokenCost)],
+      ["sleeping", String(isSleeping)]
+    ],
+    content: ""
+  };
 }
-function validateMnemonic(mnemonic) {
-  return _validateMnemonic(mnemonic, english);
+
+// src/pet/parsePetInteractionResult.ts
+var STAT_FIELDS = [
+  "hunger",
+  "happiness",
+  "health",
+  "hygiene",
+  "energy"
+];
+var HEX_64_RE = /^[0-9a-f]{64}$/i;
+function isValidStats(obj) {
+  if (typeof obj !== "object" || obj === null) return false;
+  const record = obj;
+  return STAT_FIELDS.every(
+    (field) => typeof record[field] === "number" && Number.isFinite(record[field])
+  );
 }
-function deriveNostrKey(seed) {
-  const master = HDKey.fromMasterSeed(seed);
-  const child = master.derive("m/44'/1237'/0'/0/0");
-  if (!child.privateKey) {
-    throw new Error("Failed to derive Nostr private key from seed");
+function parsePetInteractionResult(data) {
+  if (!data) return null;
+  let json;
+  try {
+    json = atob(data);
+  } catch {
+    return null;
   }
-  const secretKey = new Uint8Array(child.privateKey);
-  const pubkey = getPublicKey2(secretKey);
-  return { secretKey, pubkey };
-}
-function deriveEvmIdentity(secretKey) {
-  const account = privateKeyToAccount2(toHex3(secretKey));
+  let parsed;
+  try {
+    parsed = JSON.parse(json);
+  } catch {
+    return null;
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    return null;
+  }
+  const record = parsed;
+  if (!isValidStats(record["stats"])) return null;
+  const stage = record["stage"];
+  if (typeof stage !== "number" || !Number.isInteger(stage) || stage < 0 || stage > 2) {
+    return null;
+  }
+  const cycle = record["cycle"];
+  if (typeof cycle !== "number" || !Number.isInteger(cycle) || cycle < 0) {
+    return null;
+  }
+  const lastInteraction = record["lastInteraction"];
+  if (typeof lastInteraction !== "number" || !Number.isFinite(lastInteraction)) {
+    return null;
+  }
+  const brainHash = record["brainHash"];
+  if (typeof brainHash !== "string" || !HEX_64_RE.test(brainHash)) {
+    return null;
+  }
+  const cooldownTimestamps = record["cooldownTimestamps"];
+  if (!Array.isArray(cooldownTimestamps)) return null;
+  if (!cooldownTimestamps.every(
+    (t) => typeof t === "number" && Number.isFinite(t)
+  )) {
+    return null;
+  }
+  const validatedStats = record["stats"];
+  const stats = {
+    hunger: validatedStats.hunger,
+    happiness: validatedStats.happiness,
+    health: validatedStats.health,
+    hygiene: validatedStats.hygiene,
+    energy: validatedStats.energy
+  };
   return {
-    privateKey: secretKey,
-    address: account.address
+    stats,
+    stage,
+    cycle,
+    lastInteraction,
+    brainHash,
+    cooldownTimestamps: [...cooldownTimestamps]
   };
 }
-async function deriveSolanaKey(seed) {
-  const { hmac } = await import("@noble/hashes/hmac");
-  const { sha512 } = await import("@noble/hashes/sha512");
-  const { ed25519 } = await import("@noble/curves/ed25519");
-  const encoder = new TextEncoder();
-  let I = hmac(sha512, encoder.encode("ed25519 seed"), seed);
-  let key = I.slice(0, 32);
-  let chainCode = I.slice(32);
-  const indices = [
-    2147483692,
-    // 44'
-    2147484149,
-    // 501'
-    2147483648,
-    // 0'
-    2147483648
-    // 0'
-  ];
-  for (const index of indices) {
-    const data = new Uint8Array(37);
-    data[0] = 0;
-    data.set(key, 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);
-    chainCode = I.slice(32);
+
+// src/pet/parsePetInteractionEvent.ts
+function getTagValue(tags, name) {
+  for (const tag of tags) {
+    if (tag[0] === name) {
+      return tag[1];
+    }
   }
-  const publicKeyBytes = ed25519.getPublicKey(key);
-  const keypair = new Uint8Array(64);
-  keypair.set(key, 0);
-  keypair.set(publicKeyBytes, 32);
-  const publicKey = toBase582(publicKeyBytes);
-  return { secretKey: keypair, publicKey };
+  return void 0;
 }
-async function deriveMinaKey(seed) {
-  const master = HDKey.fromMasterSeed(seed);
-  const child = master.derive("m/44'/12586'/0'/0/0");
-  if (!child.privateKey) {
-    throw new Error("Failed to derive Mina private key from seed");
-  }
-  const keyBytes = new Uint8Array(child.privateKey);
+function isStatLike(obj) {
+  if (typeof obj !== "object" || obj === null) return false;
+  const r = obj;
+  return typeof r["hunger"] === "number" && Number.isFinite(r["hunger"]) && typeof r["happiness"] === "number" && Number.isFinite(r["happiness"]) && typeof r["health"] === "number" && Number.isFinite(r["health"]) && typeof r["hygiene"] === "number" && Number.isFinite(r["hygiene"]) && typeof r["energy"] === "number" && Number.isFinite(r["energy"]);
+}
+function cleanStats(obj) {
+  return {
+    hunger: obj["hunger"],
+    happiness: obj["happiness"],
+    health: obj["health"],
+    hygiene: obj["hygiene"],
+    energy: obj["energy"]
+  };
+}
+function parseContent(content) {
   try {
-    const MinaSignerLib = await import("./mina-signer-J7GFWOGO.js");
-    const Client = "default" in MinaSignerLib ? MinaSignerLib.default : MinaSignerLib;
-    const client = new Client({ network: "mainnet" });
-    const hexKey = Array.from(keyBytes).map((b) => b.toString(16).padStart(2, "0")).join("");
-    const keypair = client.derivePublicKey(hexKey);
+    const parsed = JSON.parse(content);
+    if (typeof parsed !== "object" || parsed === null) return null;
+    if (!isStatLike(parsed.priorStats) || !isStatLike(parsed.decayedStats) || !isStatLike(parsed.finalStats)) {
+      return null;
+    }
+    if (typeof parsed.cycle !== "number" || typeof parsed.stage !== "number" || typeof parsed.tokenCost !== "number") {
+      return null;
+    }
     return {
-      privateKey: hexKey,
-      publicKey: keypair
+      priorStats: cleanStats(parsed.priorStats),
+      decayedStats: cleanStats(parsed.decayedStats),
+      finalStats: cleanStats(parsed.finalStats),
+      cycle: parsed.cycle,
+      stage: parsed.stage,
+      tokenCost: parsed.tokenCost
     };
   } catch {
-    throw new Error(
-      "mina-signer is required for Mina key derivation. Install it as an optional dependency."
-    );
+    return null;
   }
 }
-async function deriveFullIdentity(mnemonic) {
-  const seed = mnemonicToSeedSync(mnemonic);
-  const nostr = deriveNostrKey(seed);
-  const evm = deriveEvmIdentity(nostr.secretKey);
-  let solana;
-  try {
-    solana = await deriveSolanaKey(seed);
-  } catch {
-    solana = { secretKey: new Uint8Array(64), publicKey: "" };
+function parsePetInteractionEvent(event) {
+  const tags = event.tags;
+  const blobbiId = getTagValue(tags, "d");
+  if (!blobbiId) return null;
+  const actionStr = getTagValue(tags, "action");
+  if (!actionStr) return null;
+  const actionType = Number(actionStr);
+  if (!Number.isFinite(actionType)) return null;
+  const itemStr = getTagValue(tags, "item");
+  if (!itemStr) return null;
+  const itemId = Number(itemStr);
+  if (!Number.isFinite(itemId)) return null;
+  const costStr = getTagValue(tags, "cost");
+  if (!costStr) return null;
+  const tokenCost = Number(costStr);
+  if (!Number.isFinite(tokenCost)) return null;
+  const cycleStr = getTagValue(tags, "cycle");
+  if (!cycleStr) return null;
+  const cycle = Number(cycleStr);
+  if (!Number.isFinite(cycle)) return null;
+  const stageStr = getTagValue(tags, "stage");
+  if (!stageStr) return null;
+  const stage = Number(stageStr);
+  if (!Number.isFinite(stage)) return null;
+  const brainHash = getTagValue(tags, "brain_hash");
+  if (!brainHash) return null;
+  const proof = getTagValue(tags, "proof");
+  const minaTx = getTagValue(tags, "mina_tx");
+  const proofStatus = proof && minaTx ? "proven" : "optimistic";
+  const content = parseContent(event.content);
+  const result = {
+    blobbiId,
+    actionType,
+    itemId,
+    tokenCost,
+    cycle,
+    stage,
+    brainHash,
+    proofStatus,
+    content
+  };
+  if (proof) result.proof = proof;
+  if (minaTx) result.minaTx = minaTx;
+  return result;
+}
+
+// src/pet/buildPetListingEvent.ts
+var PET_LISTING_KIND = 30402;
+var STAGE_NAMES = {
+  0: "Egg",
+  1: "Baby",
+  2: "Adult"
+};
+function buildPetListingEvent(params) {
+  const {
+    blobbiId,
+    askPriceUsdc,
+    lifecycleHash,
+    totalSpent,
+    stage,
+    stats,
+    sellerPubkey,
+    relayUrl,
+    expiresAt
+  } = params;
+  const stageName = STAGE_NAMES[stage] ?? "Unknown";
+  const summary = `${stageName} pet for sale \u2014 ${totalSpent} PET tokens spent (verified biography)`;
+  return {
+    kind: PET_LISTING_KIND,
+    created_at: Math.floor(Date.now() / 1e3),
+    tags: [
+      ["d", blobbiId],
+      ["title", `Pet ${blobbiId} for sale`],
+      ["price", String(askPriceUsdc), "USDC", ""],
+      ["summary", summary],
+      ["t", "pet"],
+      ["t", "toon-pet"],
+      ["lifecycle_hash", lifecycleHash],
+      ["total_spent", totalSpent],
+      ["stage", String(stage)],
+      ["expiration", String(expiresAt)],
+      ["relay", relayUrl],
+      ["p", sellerPubkey]
+    ],
+    content: JSON.stringify(stats)
+  };
+}
+
+// src/pet/parsePetListing.ts
+var HEX_64_RE2 = /^[0-9a-f]{64}$/i;
+function getTagValue2(tags, name) {
+  for (const tag of tags) {
+    if (tag[0] === name) {
+      return tag[1];
+    }
   }
-  let mina;
+  return void 0;
+}
+var DEFAULT_STATS = {
+  hunger: 0,
+  happiness: 0,
+  health: 0,
+  hygiene: 0,
+  energy: 0
+};
+function parseStats(content) {
   try {
-    mina = await deriveMinaKey(seed);
+    const parsed = JSON.parse(content);
+    if (typeof parsed !== "object" || parsed === null) return DEFAULT_STATS;
+    const r = parsed;
+    if (typeof r["hunger"] === "number" && typeof r["happiness"] === "number" && typeof r["health"] === "number" && typeof r["hygiene"] === "number" && typeof r["energy"] === "number") {
+      return {
+        hunger: r["hunger"],
+        happiness: r["happiness"],
+        health: r["health"],
+        hygiene: r["hygiene"],
+        energy: r["energy"]
+      };
+    }
+    return DEFAULT_STATS;
   } catch {
-    mina = { privateKey: "", publicKey: "" };
+    return DEFAULT_STATS;
   }
-  seed.fill(0);
-  return { nostr, evm, solana, mina };
 }
-function deriveFromNsec(secretKey) {
-  const keyCopy = new Uint8Array(secretKey);
-  const pubkey = getPublicKey2(keyCopy);
-  const evm = deriveEvmIdentity(keyCopy);
+function parsePetListing(event) {
+  if (event.kind !== 30402) return null;
+  const { tags } = event;
+  const blobbiId = getTagValue2(tags, "d");
+  if (!blobbiId || blobbiId.trim() === "") return null;
+  let askPriceUsdc = 0;
+  let foundPrice = false;
+  for (const tag of tags) {
+    if (tag[0] === "price") {
+      const priceStr = tag[1];
+      if (priceStr === void 0) return null;
+      const parsed = Number(priceStr);
+      if (!Number.isFinite(parsed) || parsed <= 0) return null;
+      askPriceUsdc = parsed;
+      foundPrice = true;
+      break;
+    }
+  }
+  if (!foundPrice) return null;
+  const lifecycleHash = getTagValue2(tags, "lifecycle_hash");
+  if (!lifecycleHash) return null;
+  if (!HEX_64_RE2.test(lifecycleHash)) return null;
+  const totalSpent = getTagValue2(tags, "total_spent");
+  if (totalSpent === void 0 || totalSpent === "") return null;
+  const totalSpentNum = Number(totalSpent);
+  if (!Number.isFinite(totalSpentNum) || totalSpentNum < 0) return null;
+  const stageStr = getTagValue2(tags, "stage");
+  if (stageStr === void 0) return null;
+  const stage = Number(stageStr);
+  if (!Number.isFinite(stage)) return null;
+  const sellerPubkey = getTagValue2(tags, "p") ?? "";
+  const relayUrl = getTagValue2(tags, "relay") ?? "";
+  const expiresAtStr = getTagValue2(tags, "expiration");
+  const expiresAt = expiresAtStr !== void 0 ? Number(expiresAtStr) : 0;
+  const stats = parseStats(event.content);
   return {
-    nostr: { secretKey: keyCopy, pubkey },
-    evm,
-    solana: { secretKey: new Uint8Array(64), publicKey: "" },
-    mina: { privateKey: "", publicKey: "" }
+    blobbiId,
+    askPriceUsdc,
+    lifecycleHash,
+    totalSpent,
+    stage,
+    stats,
+    sellerPubkey,
+    relayUrl,
+    expiresAt,
+    eventId: event.id,
+    createdAt: event.created_at
   };
 }
-function generateRandomIdentity() {
-  const secretKey = generateSecretKey3();
-  return deriveFromNsec(secretKey);
-}
-var BASE58_ALPHABET2 = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
-function toBase582(bytes) {
-  let num = BigInt(0);
-  for (const b of bytes) num = num * 256n + BigInt(b);
-  let result = "";
-  while (num > 0n) {
-    result = BASE58_ALPHABET2[Number(num % 58n)] + result;
-    num = num / 58n;
+
+// src/pet/filterPetListings.ts
+function compareNumericStrings(a, b) {
+  if (a === b) return 0;
+  try {
+    const bigA = BigInt(a);
+    const bigB = BigInt(b);
+    if (bigA < bigB) return -1;
+    if (bigA > bigB) return 1;
+    return 0;
+  } catch {
+    const fa = Number(a);
+    const fb = Number(b);
+    if (!Number.isFinite(fa) && !Number.isFinite(fb)) return 0;
+    if (!Number.isFinite(fa)) return -1;
+    if (!Number.isFinite(fb)) return 1;
+    return fa - fb;
   }
-  for (const b of bytes) {
-    if (b === 0) result = "1" + result;
-    else break;
+}
+function filterPetListings(events, options) {
+  const now = Math.floor(Date.now() / 1e3);
+  const listings = [];
+  for (const event of events) {
+    const listing = parsePetListing(event);
+    if (listing === null) continue;
+    if (listing.expiresAt > 0 && listing.expiresAt < now) continue;
+    if (options?.minStage !== void 0 && listing.stage < options.minStage) {
+      continue;
+    }
+    if (options?.maxAskPriceUsdc !== void 0 && listing.askPriceUsdc > options.maxAskPriceUsdc) {
+      continue;
+    }
+    if (options?.minTotalSpent !== void 0) {
+      if (compareNumericStrings(listing.totalSpent, options.minTotalSpent) < 0) {
+        continue;
+      }
+    }
+    if (options?.sellerPubkey !== void 0 && listing.sellerPubkey !== options.sellerPubkey) {
+      continue;
+    }
+    listings.push(listing);
   }
-  return result;
+  listings.sort((a, b) => compareNumericStrings(b.totalSpent, a.totalSpent));
+  return listings;
 }
 
+// src/pet/buildPetPurchaseRequest.ts
+import { PET_INTERACTION_REQUEST_KIND as PET_INTERACTION_REQUEST_KIND3 } from "@toon-protocol/core";
+var TRANSFER_OWNERSHIP_ACTION = 9;
+function buildPetPurchaseRequest(params) {
+  const { blobbiId, listingEventId, buyerPubkey, tokenCost, sellerPubkey } = params;
+  return {
+    kind: PET_INTERACTION_REQUEST_KIND3,
+    created_at: Math.floor(Date.now() / 1e3),
+    tags: [
+      ["action", String(TRANSFER_OWNERSHIP_ACTION)],
+      ["i", blobbiId],
+      ["listing", listingEventId],
+      ["buyer", buyerPubkey],
+      ["p", sellerPubkey],
+      ["cost", String(tokenCost)]
+    ],
+    content: ""
+  };
+}
+
+// src/keys/KeyManager.ts
+import { finalizeEvent as finalizeEvent2 } from "nostr-tools/pure";
+import { nip19 } from "nostr-tools";
+
 // src/keys/PasskeyAuth.ts
 async function registerPasskey(params) {
   const { rpId, rpName, userId, userName, prfSalt } = params;
@@ -3003,7 +5207,7 @@ function hexToBytes(hex) {
   }
   return bytes;
 }
-function bytesToHex(bytes) {
+function bytesToHex2(bytes) {
   return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
 }
 
@@ -3377,7 +5581,7 @@ var KeyManager = class {
         "Passkey did not return a userHandle. Cannot determine Nostr pubkey for recovery."
       );
     }
-    const pubkey = bytesToHex(discovery.userHandle);
+    const pubkey = bytesToHex2(discovery.userHandle);
     const vault = await fetchBackupFromRelays(pubkey, this.config.relayUrls);
     if (!vault) {
       throw new Error(
@@ -3457,7 +5661,7 @@ var KeyManager = class {
         });
         const kek = await deriveKek(registration.prfOutput);
         const credIdHash = await hashCredentialId(registration.credentialId);
-        const hexKey = bytesToHex(secretKey);
+        const hexKey = bytesToHex2(secretKey);
         this.vault = await createVault(hexKey, kek, credIdHash, prfSalt);
         this.activeCredentialIdHash = credIdHash;
         await this.saveToLocalStorage();
@@ -3652,7 +5856,7 @@ var KeyManager = class {
       this.vault,
       this.identity.nostr.secretKey
     );
-    const signedEvent = finalizeEvent(
+    const signedEvent = finalizeEvent2(
       eventTemplate,
       this.identity.nostr.secretKey
     );
@@ -3769,31 +5973,202 @@ function openDb(name) {
     request.onerror = () => reject(request.error);
   });
 }
+
+// src/keys/keystore-node.ts
+import {
+  scryptSync,
+  createCipheriv,
+  createDecipheriv,
+  randomBytes
+} from "crypto";
+import { writeFileSync as writeFileSync2, readFileSync as readFileSync2 } from "fs";
+var SCRYPT_N = 2 ** 17;
+var SCRYPT_R = 8;
+var SCRYPT_P = 1;
+var SCRYPT_KEY_LEN = 32;
+var SCRYPT_MAXMEM = SCRYPT_N * SCRYPT_R * 256 + 32 * 1024 * 1024;
+var SALT_LEN = 32;
+var IV_LEN = 12;
+var AUTH_TAG_LEN = 16;
+function assertNode() {
+  const versions = globalThis.process?.versions;
+  if (!versions?.node) {
+    throw new Error(
+      "keystore-node is Node.js-only and cannot run in a browser. Use the Passkey/IndexedDB KeyManager for browser key storage."
+    );
+  }
+}
+function encryptMnemonic2(mnemonic, password) {
+  assertNode();
+  if (typeof mnemonic !== "string" || mnemonic.length === 0) {
+    throw new Error("encryptMnemonic: mnemonic must be a non-empty string");
+  }
+  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 key = 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, {
+      authTagLength: AUTH_TAG_LEN
+    });
+    const ciphertext = Buffer.concat([
+      cipher.update(mnemonic, "utf8"),
+      cipher.final()
+    ]);
+    const tag = cipher.getAuthTag();
+    return {
+      salt: salt.toString("base64"),
+      iv: iv.toString("base64"),
+      ciphertext: ciphertext.toString("base64"),
+      tag: tag.toString("base64"),
+      version: 1
+    };
+  } finally {
+    key.fill(0);
+  }
+}
+function decryptMnemonic2(encrypted, password) {
+  assertNode();
+  if (typeof password !== "string" || password.length === 0) {
+    throw new Error("decryptMnemonic: password must be a non-empty string");
+  }
+  if (!encrypted || typeof encrypted.salt !== "string" || typeof encrypted.iv !== "string" || typeof encrypted.ciphertext !== "string" || typeof encrypted.tag !== "string") {
+    throw new Error("decryptMnemonic: malformed keystore envelope");
+  }
+  const salt = Buffer.from(encrypted.salt, "base64");
+  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, {
+    N: SCRYPT_N,
+    r: SCRYPT_R,
+    p: SCRYPT_P,
+    maxmem: SCRYPT_MAXMEM
+  });
+  try {
+    const decipher = createDecipheriv("aes-256-gcm", key, iv, {
+      authTagLength: AUTH_TAG_LEN
+    });
+    decipher.setAuthTag(tag);
+    try {
+      const plaintext = Buffer.concat([
+        decipher.update(ciphertext),
+        decipher.final()
+      ]);
+      return plaintext.toString("utf8");
+    } catch {
+      throw new Error(
+        "Decryption failed: wrong password or corrupted keystore file"
+      );
+    }
+  } finally {
+    key.fill(0);
+  }
+}
+function generateKeystore(path, password) {
+  assertNode();
+  const mnemonic = generateMnemonic();
+  const keystore = encryptMnemonic2(mnemonic, password);
+  writeKeystoreFile(path, keystore);
+  return { mnemonic, keystore };
+}
+function importKeystore(path, mnemonic, password) {
+  assertNode();
+  if (!validateMnemonic(mnemonic)) {
+    throw new Error(
+      "Invalid BIP-39 mnemonic: checksum or word-list validation failed"
+    );
+  }
+  const keystore = encryptMnemonic2(mnemonic, password);
+  writeKeystoreFile(path, keystore);
+  return keystore;
+}
+function loadKeystore(path, password) {
+  assertNode();
+  const raw = readFileSync2(path, "utf8");
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw new Error(`Keystore file at ${path} is not valid JSON`);
+  }
+  return decryptMnemonic2(parsed, password);
+}
+function writeKeystoreFile(path, keystore) {
+  assertNode();
+  writeFileSync2(path, JSON.stringify(keystore, null, 2), {
+    encoding: "utf8",
+    mode: 384
+  });
+}
 export {
+  ANON_ASSETS,
+  ANON_VERSION,
   BtpRuntimeClient,
   ChannelManager,
   ConnectorError,
   EvmSigner,
+  HS_HOSTNAME_MAX_LENGTH,
+  HS_HOSTNAME_REGEX,
   HttpConnectorAdmin,
+  HttpIlpClient,
   HttpRuntimeClient,
+  ILP_CLAIM_HEADER,
+  ILP_CLAIM_WRAPPED_HEADER,
+  ILP_PEER_ID_HEADER,
   KeyManager,
+  MinaSigner,
   NetworkError,
   OnChainChannelClient,
+  SolanaSigner,
   ToonClient,
   ToonClientError,
   ValidationError,
   applyDefaults,
+  applyNetworkPresets,
+  assertRoutableHsHostname,
   buildBackupEvent,
   buildBackupFilter,
+  buildPetInteractionRequest,
+  buildPetListingEvent,
+  buildPetPurchaseRequest,
   buildSettlementInfo,
+  decryptMnemonic2 as decryptMnemonic,
   deriveFromNsec,
   deriveFullIdentity,
+  deriveNostrKeyFromMnemonic,
+  encryptMnemonic2 as encryptMnemonic,
+  filterPetDvmProviders,
+  filterPetListings,
+  generateKeystore,
   generateMnemonic,
   generateRandomIdentity,
+  getNetworkStatus,
+  httpEndpointToBtpUrl,
+  importKeystore,
   isPrfSupported,
+  isRoutableHsHostname,
+  loadKeystore,
   parseBackupPayload,
+  parsePetInteractionEvent,
+  parsePetInteractionResult,
+  parsePetListing,
+  readDiscoveredIlpPeer,
+  readMinaDepositTotal,
+  requestBlobStorage,
+  selectAnonAsset,
+  selectIlpTransport,
+  startManagedAnonProxy,
   validateConfig,
   validateMnemonic,
-  withRetry
+  withRetry,
+  writeKeystoreFile
 };
 //# sourceMappingURL=index.js.map