@toon-protocol/client 0.4.2

package/dist/index.js

@@ -0,0 +1,1728 @@
+// src/ToonClient.ts
+import { generateSecretKey as generateSecretKey2, getPublicKey } from "nostr-tools/pure";
+
+// src/config.ts
+import { generateSecretKey } from "nostr-tools/pure";
+
+// src/errors.ts
+var ToonClientError = class extends Error {
+  constructor(message, code, cause) {
+    super(message, { cause });
+    this.code = code;
+    this.name = "ToonClientError";
+  }
+};
+var NetworkError = class extends ToonClientError {
+  constructor(message, cause) {
+    super(message, "NETWORK_ERROR", cause);
+    this.name = "NetworkError";
+  }
+};
+var ConnectorError = class extends ToonClientError {
+  constructor(message, cause) {
+    super(message, "CONNECTOR_ERROR", cause);
+    this.name = "ConnectorError";
+  }
+};
+var ValidationError = class extends ToonClientError {
+  constructor(message, cause) {
+    super(message, "VALIDATION_ERROR", cause);
+    this.name = "ValidationError";
+  }
+};
+var UnauthorizedError = class extends ToonClientError {
+  constructor(message, cause) {
+    super(message, "UNAUTHORIZED", cause);
+    this.name = "UnauthorizedError";
+  }
+};
+var PeerNotFoundError = class extends ToonClientError {
+  constructor(message, cause) {
+    super(message, "PEER_NOT_FOUND", cause);
+    this.name = "PeerNotFoundError";
+  }
+};
+var PeerAlreadyExistsError = class extends ToonClientError {
+  constructor(message, cause) {
+    super(message, "PEER_ALREADY_EXISTS", cause);
+    this.name = "PeerAlreadyExistsError";
+  }
+};
+
+// src/config.ts
+function validateConfig(config) {
+  if (config.connector !== void 0) {
+    throw new ValidationError(
+      "Embedded mode not yet implemented in ToonClient. Use connectorUrl for HTTP mode."
+    );
+  }
+  if (!config.connectorUrl) {
+    throw new ValidationError(
+      'connectorUrl is required for HTTP mode. Example: "http://localhost:8080"'
+    );
+  }
+  try {
+    const url = new URL(config.connectorUrl);
+    if (!url.protocol.startsWith("http")) {
+      throw new Error("Must be HTTP or HTTPS");
+    }
+  } catch (error) {
+    throw new ValidationError(
+      `Invalid connectorUrl: must be a valid HTTP/HTTPS URL (e.g., "http://localhost:8080"). Error: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  if (config.secretKey !== void 0) {
+    if (!config.secretKey || config.secretKey.length !== 32) {
+      throw new ValidationError(
+        "secretKey must be 32 bytes (Nostr private key)"
+      );
+    }
+  }
+  if (!config.ilpInfo?.ilpAddress) {
+    throw new ValidationError("ilpInfo.ilpAddress is required");
+  }
+  if (!config.toonEncoder || typeof config.toonEncoder !== "function") {
+    throw new ValidationError("toonEncoder function is required");
+  }
+  if (!config.toonDecoder || typeof config.toonDecoder !== "function") {
+    throw new ValidationError("toonDecoder function is required");
+  }
+  if (config.evmPrivateKey !== void 0) {
+    if (config.evmPrivateKey instanceof Uint8Array) {
+      if (config.evmPrivateKey.length !== 32) {
+        throw new ValidationError("evmPrivateKey must be 32 bytes");
+      }
+    } else if (typeof config.evmPrivateKey === "string") {
+      const hex = config.evmPrivateKey.startsWith("0x") ? config.evmPrivateKey.slice(2) : config.evmPrivateKey;
+      if (!/^[0-9a-fA-F]{64}$/.test(hex)) {
+        throw new ValidationError("evmPrivateKey must be a 32-byte hex string");
+      }
+    } else {
+      throw new ValidationError(
+        "evmPrivateKey must be a hex string or Uint8Array"
+      );
+    }
+  }
+  if (config.btpUrl !== void 0) {
+    try {
+      const url = new URL(config.btpUrl);
+      if (!url.protocol.startsWith("ws")) {
+        throw new Error("Must be WS or WSS");
+      }
+    } catch (error) {
+      throw new ValidationError(
+        `Invalid btpUrl: must be a valid WebSocket URL (e.g., "ws://localhost:3000"). Error: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  if (config.chainRpcUrls && config.supportedChains) {
+    for (const chain of Object.keys(config.chainRpcUrls)) {
+      if (!config.supportedChains.includes(chain)) {
+        throw new ValidationError(
+          `chainRpcUrls key "${chain}" is not in supportedChains`
+        );
+      }
+    }
+  }
+}
+function applyDefaults(config) {
+  const secretKey = config.secretKey ?? generateSecretKey();
+  let btpUrl = config.btpUrl;
+  if (!btpUrl && config.connectorUrl) {
+    try {
+      const url = new URL(config.connectorUrl);
+      const wsProtocol = url.protocol === "https:" ? "wss:" : "ws:";
+      btpUrl = `${wsProtocol}//${url.hostname}:3000`;
+    } catch {
+    }
+  }
+  let destinationAddress = config.destinationAddress;
+  if (!destinationAddress && config.connectorUrl) {
+    try {
+      const url = new URL(config.connectorUrl);
+      if (url.hostname === "localhost" || url.hostname === "127.0.0.1") {
+        if (url.port === "8080") {
+          destinationAddress = "g.toon.genesis";
+        } else if (url.port === "8090") {
+          destinationAddress = "g.toon.peer1";
+        } else if (url.port === "8100") {
+          destinationAddress = "g.toon.peer2";
+        } else {
+          destinationAddress = config.ilpInfo?.ilpAddress || "g.toon.relay";
+        }
+      } else {
+        destinationAddress = config.ilpInfo?.ilpAddress || "g.toon.relay";
+      }
+    } catch {
+      destinationAddress = config.ilpInfo?.ilpAddress || "g.toon.relay";
+    }
+  }
+  const evmPrivateKey = config.evmPrivateKey ?? secretKey;
+  return {
+    ...config,
+    secretKey,
+    evmPrivateKey,
+    connectorUrl: config.connectorUrl,
+    // Already validated as required
+    relayUrl: config.relayUrl ?? "ws://localhost:7100",
+    queryTimeout: config.queryTimeout ?? 3e4,
+    maxRetries: config.maxRetries ?? 3,
+    retryDelay: config.retryDelay ?? 1e3,
+    btpUrl,
+    destinationAddress
+    // Always set by logic above
+  };
+}
+function buildSettlementInfo(config) {
+  if (!config.supportedChains?.length && !config.settlementAddresses && !config.preferredTokens && !config.tokenNetworks) {
+    return void 0;
+  }
+  return {
+    ilpAddress: config.ilpInfo?.ilpAddress,
+    supportedChains: config.supportedChains,
+    settlementAddresses: config.settlementAddresses,
+    preferredTokens: config.preferredTokens,
+    tokenNetworks: config.tokenNetworks
+  };
+}
+
+// src/modes/http.ts
+import { BootstrapService, createDiscoveryTracker } from "@toon-protocol/core";
+
+// src/utils/retry.ts
+async function withRetry(operation, options) {
+  const {
+    maxRetries,
+    retryDelay,
+    exponentialBackoff = true,
+    maxDelay = 3e4,
+    shouldRetry
+  } = options;
+  let lastError;
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      return await operation();
+    } catch (error) {
+      lastError = error instanceof Error ? error : new Error(String(error));
+      if (shouldRetry && !shouldRetry(lastError)) {
+        throw lastError;
+      }
+      if (attempt === maxRetries) {
+        throw lastError;
+      }
+      const currentDelay = exponentialBackoff ? Math.min(retryDelay * Math.pow(2, attempt), maxDelay) : retryDelay;
+      await new Promise((resolve) => setTimeout(resolve, currentDelay));
+    }
+  }
+  throw lastError ?? new Error("Unknown error during retry");
+}
+
+// src/adapters/HttpRuntimeClient.ts
+var HttpRuntimeClient = class {
+  connectorUrl;
+  timeout;
+  retryConfig;
+  httpClient;
+  constructor(config) {
+    this.connectorUrl = config.connectorUrl.replace(/\/$/, "");
+    this.timeout = config.timeout ?? 3e4;
+    this.retryConfig = {
+      maxRetries: config.maxRetries ?? 3,
+      retryDelay: config.retryDelay ?? 1e3
+    };
+    this.httpClient = config.httpClient ?? fetch;
+  }
+  /**
+   * Send an ILP packet to the connector runtime API.
+   *
+   * @param params - ILP packet parameters
+   * @returns ILP packet response with acceptance status
+   * @throws {ValidationError} If request parameters are invalid
+   * @throws {NetworkError} If network connection fails after retries
+   * @throws {ConnectorError} If connector returns 5xx server error
+   */
+  async sendIlpPacket(params) {
+    this.validateRequest(params);
+    return withRetry(async () => this.sendHttpRequest(params), {
+      maxRetries: this.retryConfig.maxRetries,
+      retryDelay: this.retryConfig.retryDelay,
+      exponentialBackoff: true,
+      shouldRetry: (error) => {
+        return error instanceof NetworkError;
+      }
+    });
+  }
+  /**
+   * Validate ILP packet request parameters.
+   *
+   * @throws {ValidationError} If any parameter is invalid
+   */
+  validateRequest(params) {
+    if (!params.destination || params.destination.trim() === "") {
+      throw new ValidationError("Destination cannot be empty");
+    }
+    if (!params.destination.startsWith("g.")) {
+      throw new ValidationError(
+        `Invalid ILP address format: "${params.destination}" (must start with "g.")`
+      );
+    }
+    if (!params.amount || params.amount.trim() === "") {
+      throw new ValidationError("Amount cannot be empty");
+    }
+    try {
+      const amountBigInt = BigInt(params.amount);
+      if (amountBigInt <= 0n) {
+        throw new ValidationError(
+          `Amount must be positive: "${params.amount}"`
+        );
+      }
+    } catch (error) {
+      if (error instanceof ValidationError) throw error;
+      throw new ValidationError(
+        `Amount must be a valid integer: "${params.amount}"`,
+        error instanceof Error ? error : void 0
+      );
+    }
+    if (!params.data || params.data.trim() === "") {
+      throw new ValidationError("Data cannot be empty");
+    }
+    try {
+      Buffer.from(params.data, "base64");
+      if (!/^[A-Za-z0-9+/]*={0,2}$/.test(params.data)) {
+        throw new ValidationError(
+          `Data must be valid Base64 encoding: "${params.data}"`
+        );
+      }
+    } catch (error) {
+      if (error instanceof ValidationError) throw error;
+      throw new ValidationError(
+        `Data must be valid Base64 encoding: "${params.data}"`,
+        error instanceof Error ? error : void 0
+      );
+    }
+  }
+  /**
+   * Send HTTP POST request to connector runtime API.
+   *
+   * @throws {NetworkError} On connection failures (ECONNREFUSED, ETIMEDOUT)
+   * @throws {ConnectorError} On 5xx server errors
+   * @returns IlpSendResult with acceptance status
+   */
+  async sendHttpRequest(params) {
+    const requestTimeout = params.timeout ?? this.timeout;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), requestTimeout);
+    try {
+      const response = await this.httpClient(
+        `${this.connectorUrl}/admin/ilp/send`,
+        {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify({
+            destination: params.destination,
+            amount: params.amount,
+            data: params.data
+          }),
+          signal: controller.signal
+        }
+      );
+      clearTimeout(timeoutId);
+      if (response.ok) {
+        const result = await response.json();
+        return {
+          accepted: result["accepted"] ?? false,
+          fulfillment: result["fulfillment"],
+          data: result["data"],
+          code: result["code"],
+          message: result["message"]
+        };
+      } else if (response.status >= 400 && response.status < 500) {
+        const errorBody = await response.json().catch(() => ({}));
+        return {
+          accepted: false,
+          code: `HTTP_${response.status}`,
+          message: errorBody["message"] ?? errorBody["error"] ?? response.statusText
+        };
+      } else if (response.status >= 500 && response.status < 600) {
+        const errorBody = await response.json().catch(() => ({}));
+        throw new ConnectorError(
+          `Connector server error (${response.status}): ${errorBody["message"] ?? errorBody["error"] ?? response.statusText}`
+        );
+      }
+      throw new ConnectorError(
+        `Unexpected HTTP status: ${response.status} ${response.statusText}`
+      );
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof Error && error.name === "AbortError") {
+        throw new NetworkError(
+          `Request timeout after ${requestTimeout}ms`,
+          error
+        );
+      }
+      if (error instanceof TypeError && (error.message.includes("fetch failed") || error.message.includes("ECONNREFUSED") || error.message.includes("ETIMEDOUT") || error.message.includes("network"))) {
+        throw new NetworkError(
+          `Network connection failed: ${error.message}`,
+          error
+        );
+      }
+      if (error instanceof NetworkError || error instanceof ConnectorError || error instanceof ValidationError) {
+        throw error;
+      }
+      throw new ConnectorError(
+        `Unexpected error during HTTP request: ${error instanceof Error ? error.message : String(error)}`,
+        error instanceof Error ? error : void 0
+      );
+    }
+  }
+};
+
+// src/adapters/BtpRuntimeClient.ts
+import { BTPClient } from "@toon-protocol/connector";
+var BTP_CLAIM_PROTOCOL = {
+  NAME: "payment-channel-claim",
+  CONTENT_TYPE: 1
+};
+function createConsoleLogger() {
+  const noop = (..._args) => {
+  };
+  const logger = {
+    level: "info",
+    silent: noop,
+    info: console.info.bind(console),
+    warn: console.warn.bind(console),
+    error: console.error.bind(console),
+    debug: console.debug.bind(console),
+    trace: console.debug.bind(console),
+    fatal: console.error.bind(console),
+    child: () => createConsoleLogger()
+  };
+  return logger;
+}
+var ILP_PACKET_TYPE = {
+  PREPARE: 12,
+  FULFILL: 13,
+  REJECT: 14
+};
+function isConnectionError(error) {
+  const msg = error.message.toLowerCase();
+  return msg.includes("not connected") || msg.includes("connection") || msg.includes("websocket") || msg.includes("econnrefused") || msg.includes("econnreset") || msg.includes("socket hang up") || msg.includes("timeout");
+}
+var BtpRuntimeClient = class {
+  btpClient = null;
+  config;
+  _isConnected = false;
+  logger;
+  constructor(config) {
+    this.config = config;
+    this.logger = config.logger ?? createConsoleLogger();
+  }
+  /**
+   * Connects to the BTP peer via WebSocket.
+   */
+  async connect() {
+    const peer = {
+      id: this.config.peerId,
+      url: this.config.btpUrl,
+      authToken: this.config.authToken,
+      connected: false,
+      lastSeen: /* @__PURE__ */ new Date()
+    };
+    this.btpClient = new BTPClient(
+      peer,
+      this.config.peerId,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      this.logger
+    );
+    await this.btpClient.connect();
+    this._isConnected = true;
+  }
+  /**
+   * Attempts to reconnect by creating a fresh BTPClient and connecting.
+   */
+  async reconnect() {
+    if (this.btpClient) {
+      try {
+        await this.btpClient.disconnect();
+      } catch {
+      }
+      this.btpClient = null;
+      this._isConnected = false;
+    }
+    this.logger.info("[BtpRuntimeClient] Reconnecting...");
+    await this.connect();
+  }
+  /**
+   * Disconnects from the BTP peer.
+   */
+  async disconnect() {
+    if (this.btpClient) {
+      await this.btpClient.disconnect();
+      this._isConnected = false;
+      this.btpClient = null;
+    }
+  }
+  get isConnected() {
+    return this._isConnected;
+  }
+  /**
+   * Sends an ILP packet via BTP with auto-reconnect on connection errors.
+   * Satisfies IlpClient interface.
+   */
+  async sendIlpPacket(params) {
+    return withRetry(() => this._sendIlpPacketOnce(params), {
+      maxRetries: this.config.maxRetries ?? 3,
+      retryDelay: this.config.retryDelay ?? 1e3,
+      shouldRetry: (error) => {
+        if (!isConnectionError(error)) return false;
+        this._isConnected = false;
+        return true;
+      }
+    });
+  }
+  /**
+   * Sends a balance proof claim via BTP protocol data, then sends an ILP packet.
+   * Auto-reconnects on connection errors.
+   */
+  async sendIlpPacketWithClaim(params, claim) {
+    return withRetry(() => this._sendIlpPacketWithClaimOnce(params, claim), {
+      maxRetries: this.config.maxRetries ?? 3,
+      retryDelay: this.config.retryDelay ?? 1e3,
+      shouldRetry: (error) => {
+        if (!isConnectionError(error)) return false;
+        this._isConnected = false;
+        return true;
+      }
+    });
+  }
+  /**
+   * Single-attempt ILP packet send. Reconnects if not connected.
+   */
+  async _sendIlpPacketOnce(params) {
+    if (!this._isConnected) {
+      await this.reconnect();
+    }
+    const packet = {
+      type: ILP_PACKET_TYPE.PREPARE,
+      amount: BigInt(params.amount),
+      destination: params.destination,
+      executionCondition: Buffer.alloc(32),
+      expiresAt: new Date(Date.now() + (params.timeout ?? 3e4)),
+      data: Buffer.from(params.data, "base64")
+    };
+    const response = await this.btpClient?.sendPacket(packet);
+    if (!response) {
+      throw new Error("BTP client not connected");
+    }
+    if (response.type === ILP_PACKET_TYPE.FULFILL) {
+      const fulfill = response;
+      return {
+        accepted: true,
+        fulfillment: fulfill.fulfillment.toString("base64"),
+        data: fulfill.data.length > 0 ? fulfill.data.toString("base64") : void 0
+      };
+    }
+    const reject = response;
+    return {
+      accepted: false,
+      code: reject.code,
+      message: reject.message,
+      data: reject.data.length > 0 ? reject.data.toString("base64") : void 0
+    };
+  }
+  /**
+   * Single-attempt claim + ILP packet send. Reconnects if not connected.
+   */
+  async _sendIlpPacketWithClaimOnce(params, claim) {
+    if (!this._isConnected) {
+      await this.reconnect();
+    }
+    if (!this.btpClient) {
+      throw new Error("BTP client not connected");
+    }
+    await this.btpClient.sendProtocolData(
+      BTP_CLAIM_PROTOCOL.NAME,
+      BTP_CLAIM_PROTOCOL.CONTENT_TYPE,
+      Buffer.from(JSON.stringify(claim))
+    );
+    return this._sendIlpPacketOnce(params);
+  }
+};
+
+// 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 = [
+  {
+    name: "approve",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "spender", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: [{ type: "bool" }]
+  },
+  {
+    name: "allowance",
+    type: "function",
+    stateMutability: "view",
+    inputs: [
+      { name: "owner", type: "address" },
+      { name: "spender", type: "address" }
+    ],
+    outputs: [{ type: "uint256" }]
+  }
+];
+var STATE_MAP = {
+  0: "settled",
+  1: "open",
+  2: "closed",
+  3: "settled"
+};
+var OnChainChannelClient = class {
+  evmSigner;
+  chainRpcUrls;
+  channelContext = /* @__PURE__ */ new Map();
+  constructor(config) {
+    this.evmSigner = config.evmSigner;
+    this.chainRpcUrls = config.chainRpcUrls;
+  }
+  /**
+   * Parse chain identifier to extract chainId.
+   * Format: "evm:{network}:{chainId}" e.g., "evm:anvil:31337"
+   */
+  parseChainId(chain) {
+    const parts = chain.split(":");
+    if (parts.length < 3) {
+      throw new Error(
+        `Invalid chain format: "${chain}". Expected "evm:{network}:{chainId}".`
+      );
+    }
+    const chainIdStr = parts[2];
+    if (!chainIdStr) {
+      throw new Error(
+        `Invalid chain format: "${chain}". Expected "evm:{network}:{chainId}".`
+      );
+    }
+    const chainId = parseInt(chainIdStr, 10);
+    if (isNaN(chainId)) {
+      throw new Error(`Invalid chainId in chain "${chain}".`);
+    }
+    return chainId;
+  }
+  /**
+   * Create viem clients for a given chain.
+   */
+  createClients(chain) {
+    const rpcUrl = this.chainRpcUrls[chain];
+    if (!rpcUrl) {
+      throw new Error(
+        `No RPC URL configured for chain "${chain}". Available: ${Object.keys(this.chainRpcUrls).join(", ")}`
+      );
+    }
+    const chainId = this.parseChainId(chain);
+    const viemChain = defineChain({
+      id: chainId,
+      name: chain,
+      nativeCurrency: { name: "ETH", symbol: "ETH", decimals: 18 },
+      rpcUrls: { default: { http: [rpcUrl] } }
+    });
+    const publicClient = createPublicClient({
+      transport: http(rpcUrl),
+      chain: viemChain
+    });
+    const walletClient = createWalletClient({
+      account: this.evmSigner.account,
+      transport: http(rpcUrl),
+      chain: viemChain
+    });
+    return { publicClient, walletClient };
+  }
+  /**
+   * Opens a new payment channel on-chain.
+   *
+   * 1. Approve token spend if needed
+   * 2. Call TokenNetwork.openChannel()
+   * 3. Extract channelId from ChannelOpened event
+   * 4. Deposit initial funds if specified
+   */
+  async openChannel(params) {
+    const {
+      chain,
+      tokenNetwork,
+      peerAddress,
+      initialDeposit,
+      settlementTimeout
+    } = params;
+    if (!tokenNetwork) {
+      throw new Error(
+        "tokenNetwork address is required for on-chain channel opening"
+      );
+    }
+    const { publicClient, walletClient } = this.createClients(chain);
+    const tokenNetworkAddr = tokenNetwork;
+    const deposit = initialDeposit ? BigInt(initialDeposit) : 0n;
+    if (deposit > 0n && params.token) {
+      const tokenAddr = params.token;
+      const myAddress = this.evmSigner.address;
+      const currentAllowance = await publicClient.readContract({
+        address: tokenAddr,
+        abi: ERC20_ABI,
+        functionName: "allowance",
+        args: [myAddress, tokenNetworkAddr]
+      });
+      if (currentAllowance < deposit) {
+        const approveHash = await walletClient.writeContract({
+          address: tokenAddr,
+          abi: ERC20_ABI,
+          functionName: "approve",
+          args: [tokenNetworkAddr, maxUint256]
+        });
+        await publicClient.waitForTransactionReceipt({ hash: approveHash });
+      }
+    }
+    const timeout = BigInt(settlementTimeout ?? 86400);
+    const openHash = await walletClient.writeContract({
+      address: tokenNetworkAddr,
+      abi: TOKEN_NETWORK_ABI,
+      functionName: "openChannel",
+      args: [peerAddress, timeout]
+    });
+    const receipt = await publicClient.waitForTransactionReceipt({ hash: openHash });
+    let channelId;
+    for (const log of receipt.logs) {
+      try {
+        const decoded = decodeEventLog({
+          abi: TOKEN_NETWORK_ABI,
+          data: log.data,
+          topics: log.topics
+        });
+        if (decoded.eventName === "ChannelOpened") {
+          channelId = decoded.args["channelId"];
+          break;
+        }
+      } catch {
+      }
+    }
+    if (!channelId) {
+      throw new Error("Failed to extract channelId from ChannelOpened event");
+    }
+    this.channelContext.set(channelId, {
+      chain,
+      tokenNetworkAddress: tokenNetwork
+    });
+    if (deposit > 0n) {
+      const depositHash = await walletClient.writeContract({
+        address: tokenNetworkAddr,
+        abi: TOKEN_NETWORK_ABI,
+        functionName: "setTotalDeposit",
+        args: [channelId, this.evmSigner.address, deposit]
+      });
+      await publicClient.waitForTransactionReceipt({ hash: depositHash });
+    }
+    return { channelId, status: "opening" };
+  }
+  /**
+   * Gets the current state of a payment channel from on-chain data.
+   */
+  async getChannelState(channelId) {
+    const context = this.channelContext.get(channelId);
+    if (!context) {
+      throw new Error(
+        `No context for channel "${channelId}". Channel must be opened via this client first.`
+      );
+    }
+    const { publicClient } = this.createClients(context.chain);
+    const result = await publicClient.readContract({
+      address: context.tokenNetworkAddress,
+      abi: TOKEN_NETWORK_ABI,
+      functionName: "channels",
+      args: [channelId]
+    });
+    const [, state] = result;
+    const status = STATE_MAP[state] ?? "settled";
+    return {
+      channelId,
+      status,
+      chain: context.chain
+    };
+  }
+};
+
+// src/signing/evm-signer.ts
+import { privateKeyToAccount } from "viem/accounts";
+import { toHex } from "viem";
+function getBalanceProofDomain(chainId, tokenNetworkAddress) {
+  return {
+    name: "TokenNetwork",
+    version: "1",
+    chainId,
+    verifyingContract: tokenNetworkAddress
+  };
+}
+var BALANCE_PROOF_TYPES = {
+  BalanceProof: [
+    { name: "channelId", type: "bytes32" },
+    { name: "nonce", type: "uint256" },
+    { name: "transferredAmount", type: "uint256" },
+    { name: "lockedAmount", type: "uint256" },
+    { name: "locksRoot", type: "bytes32" }
+  ]
+};
+var EvmSigner = class {
+  _account;
+  /**
+   * @param privateKey - EVM private key as hex string (with or without 0x prefix) or Uint8Array
+   */
+  constructor(privateKey) {
+    let hexKey;
+    if (privateKey instanceof Uint8Array) {
+      hexKey = toHex(privateKey);
+    } else {
+      hexKey = privateKey.startsWith("0x") ? privateKey : `0x${privateKey}`;
+    }
+    this._account = privateKeyToAccount(hexKey);
+  }
+  /** Derived 0x EVM address */
+  get address() {
+    return this._account.address;
+  }
+  /** Viem PrivateKeyAccount — usable with walletClient for on-chain transactions */
+  get account() {
+    return this._account;
+  }
+  /**
+   * Signs a balance proof using EIP-712 typed data.
+   *
+   * @param params - Balance proof parameters plus chain context
+   * @returns Signed balance proof with signature
+   */
+  async signBalanceProof(params) {
+    const domain = getBalanceProofDomain(
+      params.chainId,
+      params.tokenNetworkAddress
+    );
+    const signature = await this._account.signTypedData({
+      domain,
+      types: BALANCE_PROOF_TYPES,
+      primaryType: "BalanceProof",
+      message: {
+        channelId: params.channelId,
+        nonce: BigInt(params.nonce),
+        transferredAmount: params.transferredAmount,
+        lockedAmount: params.lockedAmount,
+        locksRoot: params.locksRoot
+      }
+    });
+    return {
+      channelId: params.channelId,
+      nonce: params.nonce,
+      transferredAmount: params.transferredAmount,
+      lockedAmount: params.lockedAmount,
+      locksRoot: params.locksRoot,
+      signature,
+      signerAddress: this._account.address
+    };
+  }
+  /**
+   * Builds an EVMClaimMessage from a signed balance proof.
+   * Static so it can be called without an EvmSigner instance.
+   *
+   * @param proof - Signed balance proof
+   * @param senderId - Nostr pubkey or identifier of the sender
+   * @returns EVMClaimMessage compatible with BTP_CLAIM_PROTOCOL
+   */
+  static buildClaimMessage(proof, senderId) {
+    return {
+      blockchain: "evm",
+      senderId,
+      channelId: proof.channelId,
+      nonce: proof.nonce,
+      transferredAmount: proof.transferredAmount.toString(),
+      lockedAmount: proof.lockedAmount.toString(),
+      locksRoot: proof.locksRoot,
+      signature: proof.signature,
+      signerAddress: proof.signerAddress
+    };
+  }
+};
+
+// src/modes/http.ts
+async function initializeHttpMode(config) {
+  const connectorUrl = config.connectorUrl;
+  const settlementInfo = buildSettlementInfo(config);
+  let btpClient = null;
+  if (config.btpUrl) {
+    btpClient = new BtpRuntimeClient({
+      btpUrl: config.btpUrl,
+      peerId: config.btpPeerId ?? `client`,
+      authToken: config.btpAuthToken ?? ""
+    });
+    await btpClient.connect();
+  }
+  const runtimeClient = btpClient ?? new HttpRuntimeClient({
+    connectorUrl,
+    timeout: config.queryTimeout,
+    maxRetries: config.maxRetries,
+    retryDelay: config.retryDelay
+  });
+  let onChainChannelClient = null;
+  if (config.chainRpcUrls) {
+    const evmSigner = new EvmSigner(config.evmPrivateKey);
+    onChainChannelClient = new OnChainChannelClient({
+      evmSigner,
+      chainRpcUrls: config.chainRpcUrls
+    });
+  }
+  const bootstrapConfig = {
+    knownPeers: (config.knownPeers || []).map((p) => ({
+      pubkey: p.pubkey,
+      relayUrl: p.relayUrl,
+      btpEndpoint: p.btpEndpoint ?? ""
+    })),
+    queryTimeout: config.queryTimeout,
+    ardriveEnabled: true,
+    defaultRelayUrl: config.relayUrl,
+    settlementInfo,
+    ownIlpAddress: config.ilpInfo.ilpAddress,
+    toonEncoder: config.toonEncoder,
+    toonDecoder: config.toonDecoder,
+    basePricePerByte: 10n
+    // Default pricing
+  };
+  const bootstrapService = new BootstrapService(
+    bootstrapConfig,
+    config.secretKey,
+    config.ilpInfo
+  );
+  bootstrapService.setIlpClient(runtimeClient);
+  if (onChainChannelClient) {
+    bootstrapService.setChannelClient(onChainChannelClient);
+  }
+  const discoveryTracker = createDiscoveryTracker({
+    secretKey: config.secretKey,
+    settlementInfo
+  });
+  return {
+    bootstrapService,
+    discoveryTracker,
+    runtimeClient,
+    adminClient: null,
+    btpClient,
+    onChainChannelClient
+  };
+}
+
+// src/channel/ChannelManager.ts
+var ChannelManager = class {
+  evmSigner;
+  channels = /* @__PURE__ */ new Map();
+  store;
+  constructor(evmSigner, store) {
+    this.evmSigner = evmSigner;
+    this.store = store;
+  }
+  /**
+   * Start tracking a channel.
+   * Called after bootstrap returns a channelId.
+   *
+   * @param channelId - Payment channel identifier
+   * @param initialNonce - Starting nonce (default: 0)
+   * @param initialAmount - Starting cumulative amount (default: 0n)
+   */
+  trackChannel(channelId, initialNonce = 0, initialAmount = 0n) {
+    if (this.store) {
+      const persisted = this.store.load(channelId);
+      if (persisted) {
+        this.channels.set(channelId, {
+          nonce: persisted.nonce,
+          cumulativeAmount: persisted.cumulativeAmount
+        });
+        return;
+      }
+    }
+    this.channels.set(channelId, {
+      nonce: initialNonce,
+      cumulativeAmount: initialAmount
+    });
+  }
+  /**
+   * Signs a balance proof for the given channel.
+   * Auto-increments nonce and adds to cumulative amount.
+   *
+   * @param channelId - Payment channel identifier
+   * @param additionalAmount - Amount to add to cumulative transferred amount
+   * @returns Signed balance proof
+   * @throws Error if channel is not being tracked
+   */
+  async signBalanceProof(channelId, additionalAmount) {
+    const tracking = this.channels.get(channelId);
+    if (!tracking) {
+      throw new Error(
+        `Channel "${channelId}" is not being tracked. Call trackChannel() first.`
+      );
+    }
+    tracking.nonce += 1;
+    tracking.cumulativeAmount += additionalAmount;
+    if (this.store) {
+      this.store.save(channelId, {
+        nonce: tracking.nonce,
+        cumulativeAmount: tracking.cumulativeAmount
+      });
+    }
+    return this.evmSigner.signBalanceProof({
+      channelId,
+      nonce: tracking.nonce,
+      transferredAmount: tracking.cumulativeAmount,
+      lockedAmount: 0n,
+      locksRoot: "0x0000000000000000000000000000000000000000000000000000000000000000",
+      chainId: 31337,
+      // Default — will be configurable via channel context
+      tokenNetworkAddress: "0x0000000000000000000000000000000000000000"
+    });
+  }
+  /**
+   * Gets the current nonce for a tracked channel.
+   */
+  getNonce(channelId) {
+    const tracking = this.channels.get(channelId);
+    if (!tracking) {
+      throw new Error(`Channel "${channelId}" is not being tracked.`);
+    }
+    return tracking.nonce;
+  }
+  /**
+   * Gets the cumulative transferred amount for a tracked channel.
+   */
+  getCumulativeAmount(channelId) {
+    const tracking = this.channels.get(channelId);
+    if (!tracking) {
+      throw new Error(`Channel "${channelId}" is not being tracked.`);
+    }
+    return tracking.cumulativeAmount;
+  }
+  /**
+   * Gets all tracked channel IDs.
+   */
+  getTrackedChannels() {
+    return Array.from(this.channels.keys());
+  }
+  /**
+   * Returns true if the channel is being tracked.
+   */
+  isTracking(channelId) {
+    return this.channels.has(channelId);
+  }
+};
+
+// src/channel/ChannelStore.ts
+import { readFileSync, writeFileSync, existsSync } from "fs";
+var JsonFileChannelStore = class {
+  filePath;
+  constructor(filePath) {
+    this.filePath = filePath;
+  }
+  save(channelId, tracking) {
+    const data = this.readFile();
+    data[channelId] = {
+      nonce: tracking.nonce,
+      cumulativeAmount: tracking.cumulativeAmount.toString()
+    };
+    this.writeFile(data);
+  }
+  load(channelId) {
+    const data = this.readFile();
+    const entry = data[channelId];
+    if (!entry) return void 0;
+    return {
+      nonce: entry.nonce,
+      cumulativeAmount: BigInt(entry.cumulativeAmount)
+    };
+  }
+  list() {
+    return Object.keys(this.readFile());
+  }
+  delete(channelId) {
+    const data = this.readFile();
+    const { [channelId]: _, ...rest } = data;
+    this.writeFile(rest);
+  }
+  readFile() {
+    if (!existsSync(this.filePath)) {
+      return {};
+    }
+    const raw = readFileSync(this.filePath, "utf-8");
+    return JSON.parse(raw);
+  }
+  writeFile(data) {
+    writeFileSync(this.filePath, JSON.stringify(data, null, 2), "utf-8");
+  }
+};
+
+// src/ToonClient.ts
+var ToonClient = class {
+  config;
+  state = null;
+  evmSigner;
+  channelManager;
+  /**
+   * Creates a new ToonClient instance.
+   *
+   * @param config - Client configuration
+   * @throws {ValidationError} If configuration is invalid
+   */
+  constructor(config) {
+    validateConfig(config);
+    this.config = applyDefaults(config);
+    if (this.config.evmPrivateKey) {
+      this.evmSigner = new EvmSigner(this.config.evmPrivateKey);
+    }
+  }
+  /**
+   * Generates a new Nostr keypair.
+   *
+   * @returns Object with secretKey (Uint8Array) and pubkey (hex string)
+   */
+  static generateKeypair() {
+    const secretKey = generateSecretKey2();
+    const pubkey = getPublicKey(secretKey);
+    return { secretKey, pubkey };
+  }
+  /**
+   * Gets the Nostr public key derived from the secret key.
+   * Works before start() is called.
+   */
+  getPublicKey() {
+    return getPublicKey(this.config.secretKey);
+  }
+  /**
+   * Gets the EVM address derived from the Nostr secret key (or explicit evmPrivateKey override).
+   */
+  getEvmAddress() {
+    return this.evmSigner?.address;
+  }
+  /**
+   * Starts the ToonClient.
+   *
+   * This will:
+   * 1. Initialize HTTP mode components (runtime client, admin client, bootstrap, monitor)
+   * 2. Bootstrap the network (discover peers, register, and open channels)
+   * 3. Start monitoring relay for new peers (kind:10032 events)
+   *
+   * @returns Result with number of peers discovered and mode
+   * @throws {ToonClientError} If client is already started
+   * @throws {ToonClientError} If initialization fails
+   */
+  async start() {
+    if (this.state !== null) {
+      throw new ToonClientError("Client already started", "INVALID_STATE");
+    }
+    try {
+      if (this.evmSigner) {
+        const store = this.config.channelStorePath ? new JsonFileChannelStore(this.config.channelStorePath) : void 0;
+        this.channelManager = new ChannelManager(this.evmSigner, store);
+      }
+      const initialization = await initializeHttpMode(this.config);
+      const { bootstrapService, discoveryTracker, runtimeClient, btpClient } = initialization;
+      if (this.channelManager) {
+        const cm = this.channelManager;
+        bootstrapService.setClaimSigner(
+          async (channelId, amount) => {
+            if (!cm.isTracking(channelId)) {
+              cm.trackChannel(channelId);
+            }
+            return cm.signBalanceProof(channelId, amount);
+          }
+        );
+      }
+      const bootstrapResults = await bootstrapService.bootstrap();
+      if (this.channelManager) {
+        for (const result of bootstrapResults) {
+          if (result.channelId && !this.channelManager.isTracking(result.channelId)) {
+            this.channelManager.trackChannel(result.channelId);
+          }
+        }
+      }
+      this.state = {
+        bootstrapService,
+        discoveryTracker,
+        runtimeClient,
+        peersDiscovered: bootstrapResults.length,
+        btpClient: btpClient ?? void 0
+      };
+      return {
+        peersDiscovered: bootstrapResults.length,
+        mode: "http"
+      };
+    } catch (error) {
+      throw new ToonClientError(
+        "Failed to start client",
+        "INITIALIZATION_ERROR",
+        error instanceof Error ? error : void 0
+      );
+    }
+  }
+  /**
+   * Publishes a Nostr event to the relay via ILP payment.
+   *
+   * The event must already be finalized (signed with id, pubkey, sig).
+   *
+   * @param event - Signed Nostr event to publish
+   * @param options - Optional options including destination and signed balance proof claim
+   * @returns Result with success status, event ID, and fulfillment
+   * @throws {ToonClientError} If client is not started
+   * @throws {ToonClientError} If event publishing fails
+   */
+  async publishEvent(event, options) {
+    if (!this.state) {
+      throw new ToonClientError(
+        "Client not started. Call start() first.",
+        "INVALID_STATE"
+      );
+    }
+    try {
+      const toonData = this.config.toonEncoder(event);
+      const basePricePerByte = 10n;
+      const amount = String(BigInt(toonData.length) * basePricePerByte);
+      const destination = options?.destination ?? this.config.destinationAddress;
+      let response;
+      if (options?.claim && this.state.btpClient) {
+        const claimMessage = EvmSigner.buildClaimMessage(
+          options.claim,
+          this.getPublicKey()
+        );
+        response = await this.state.btpClient.sendIlpPacketWithClaim(
+          {
+            destination,
+            amount,
+            data: Buffer.from(toonData).toString("base64")
+          },
+          claimMessage
+        );
+      } else {
+        response = await this.state.runtimeClient.sendIlpPacket({
+          destination,
+          amount,
+          data: Buffer.from(toonData).toString("base64")
+        });
+      }
+      if (!response.accepted) {
+        return {
+          success: false,
+          error: `Event rejected: ${response.code} - ${response.message}`
+        };
+      }
+      return {
+        success: true,
+        eventId: event.id,
+        fulfillment: response.fulfillment
+      };
+    } catch (error) {
+      throw new ToonClientError(
+        "Failed to publish event",
+        "PUBLISH_ERROR",
+        error instanceof Error ? error : void 0
+      );
+    }
+  }
+  /**
+   * Signs a balance proof for the given channel with the specified amount.
+   * Delegates to ChannelManager which auto-increments nonce and tracks cumulative amount.
+   *
+   * @param channelId - Payment channel identifier
+   * @param amount - Additional amount to add to cumulative transferred amount
+   * @returns Signed balance proof
+   * @throws {ToonClientError} If no EVM signer configured or channel not tracked
+   */
+  async signBalanceProof(channelId, amount) {
+    if (!this.channelManager) {
+      throw new ToonClientError(
+        "No EVM signer configured. Provide evmPrivateKey in config.",
+        "NO_EVM_SIGNER"
+      );
+    }
+    return this.channelManager.signBalanceProof(channelId, amount);
+  }
+  /**
+   * Gets list of tracked payment channel IDs.
+   */
+  getTrackedChannels() {
+    return this.channelManager?.getTrackedChannels() ?? [];
+  }
+  /**
+   * Sends an ILP payment, optionally with a balance proof claim via BTP.
+   *
+   * @param params - Payment parameters
+   * @returns ILP send result
+   * @throws {ToonClientError} If client is not started
+   */
+  async sendPayment(params) {
+    if (!this.state) {
+      throw new ToonClientError(
+        "Client not started. Call start() first.",
+        "INVALID_STATE"
+      );
+    }
+    const ilpParams = {
+      destination: params.destination,
+      amount: params.amount,
+      data: params.data ?? ""
+    };
+    if (params.claim && this.state.btpClient) {
+      const claimMessage = EvmSigner.buildClaimMessage(
+        params.claim,
+        this.getPublicKey()
+      );
+      return this.state.btpClient.sendIlpPacketWithClaim(
+        ilpParams,
+        claimMessage
+      );
+    }
+    return this.state.runtimeClient.sendIlpPacket(ilpParams);
+  }
+  /**
+   * Stops the ToonClient and cleans up resources.
+   *
+   * This will:
+   * 1. Disconnect BTP client if connected
+   * 2. Clear internal state
+   *
+   * @throws {ToonClientError} If client is not started
+   */
+  async stop() {
+    if (!this.state) {
+      throw new ToonClientError("Client not started", "INVALID_STATE");
+    }
+    try {
+      if (this.state.btpClient) {
+        await this.state.btpClient.disconnect();
+      }
+      this.state = null;
+    } catch (error) {
+      throw new ToonClientError(
+        "Failed to stop client",
+        "STOP_ERROR",
+        error instanceof Error ? error : void 0
+      );
+    }
+  }
+  /**
+   * Returns true if the client is currently started.
+   */
+  isStarted() {
+    return this.state !== null;
+  }
+  /**
+   * Gets the number of peers discovered during bootstrap.
+   *
+   * @returns Number of peers discovered
+   * @throws {ToonClientError} If client is not started
+   */
+  getPeersCount() {
+    if (!this.state) {
+      throw new ToonClientError(
+        "Client not started. Call start() first.",
+        "INVALID_STATE"
+      );
+    }
+    return this.state.peersDiscovered;
+  }
+  /**
+   * Gets the list of peers discovered by the relay monitor.
+   *
+   * @returns Array of discovered peer objects
+   * @throws {ToonClientError} If client is not started
+   */
+  getDiscoveredPeers() {
+    if (!this.state) {
+      throw new ToonClientError(
+        "Client not started. Call start() first.",
+        "INVALID_STATE"
+      );
+    }
+    return this.state.discoveryTracker.getDiscoveredPeers();
+  }
+};
+
+// src/adapters/HttpConnectorAdmin.ts
+var HttpConnectorAdmin = class {
+  adminUrl;
+  timeout;
+  retryConfig;
+  httpClient;
+  constructor(config) {
+    this.adminUrl = config.adminUrl.replace(/\/$/, "");
+    this.timeout = config.timeout ?? 3e4;
+    this.retryConfig = {
+      maxRetries: config.maxRetries ?? 3,
+      retryDelay: config.retryDelay ?? 1e3
+    };
+    this.httpClient = config.httpClient ?? fetch;
+  }
+  /**
+   * Add a peer to the connector via the admin API.
+   *
+   * Validates peer config parameters and sends HTTP POST to /admin/peers.
+   *
+   * @param config - Peer configuration
+   * @param config.id - Unique peer identifier (non-empty string)
+   * @param config.url - BTP WebSocket URL (must start with 'btp+ws://' or 'btp+wss://')
+   * @param config.authToken - Authentication token (non-empty string)
+   * @param config.routes - Optional routing table entries
+   * @param config.settlement - Optional settlement configuration
+   *
+   * @throws {ValidationError} Invalid peer config (missing id, invalid url, etc.)
+   * @throws {PeerAlreadyExistsError} Peer with same ID already exists (409 Conflict)
+   * @throws {UnauthorizedError} Admin API authentication failed (401)
+   * @throws {NetworkError} Connection to admin API failed
+   * @throws {ConnectorError} Admin API server error (5xx)
+   */
+  async addPeer(config) {
+    if (!config.id || typeof config.id !== "string" || config.id.trim() === "") {
+      throw new ValidationError("Peer id must be a non-empty string");
+    }
+    if (!config.url || typeof config.url !== "string" || config.url.trim() === "") {
+      throw new ValidationError("Peer url must be a non-empty string");
+    }
+    const hasWsPrefix = config.url.startsWith("ws://") || config.url.startsWith("wss://");
+    const hasBtpPrefix = config.url.startsWith("btp+ws://") || config.url.startsWith("btp+wss://");
+    if (!hasWsPrefix && !hasBtpPrefix) {
+      throw new ValidationError(
+        `Invalid BTP URL format: "${config.url}". Must start with 'ws://', 'wss://', 'btp+ws://', or 'btp+wss://'`
+      );
+    }
+    if (config.authToken === void 0 || config.authToken === null || typeof config.authToken !== "string") {
+      throw new ValidationError(
+        "Peer authToken must be a string (can be empty for no auth)"
+      );
+    }
+    if (config.routes !== void 0) {
+      if (!Array.isArray(config.routes)) {
+        throw new ValidationError("Peer routes must be an array");
+      }
+      for (const route of config.routes) {
+        if (!route.prefix || typeof route.prefix !== "string" || route.prefix.trim() === "") {
+          throw new ValidationError("Route prefix must be a non-empty string");
+        }
+        if (route.priority !== void 0 && typeof route.priority !== "number") {
+          throw new ValidationError("Route priority must be a number");
+        }
+      }
+    }
+    if (config.settlement !== void 0) {
+      if (typeof config.settlement !== "object" || config.settlement === null) {
+        throw new ValidationError("Peer settlement must be an object");
+      }
+      if (!config.settlement.preference || typeof config.settlement.preference !== "string") {
+        throw new ValidationError(
+          "Settlement preference must be a non-empty string"
+        );
+      }
+    }
+    const url = `${this.adminUrl}/admin/peers`;
+    await withRetry(async () => this.sendAddPeerRequest(url, config), {
+      maxRetries: this.retryConfig.maxRetries,
+      retryDelay: this.retryConfig.retryDelay,
+      exponentialBackoff: true,
+      shouldRetry: (error) => {
+        return error instanceof NetworkError;
+      }
+    });
+  }
+  /**
+   * Remove a peer from the connector via the admin API.
+   *
+   * Sends HTTP DELETE to /admin/peers/:id.
+   *
+   * @param peerId - Unique peer identifier to remove (non-empty string)
+   *
+   * @throws {ValidationError} Invalid peerId (empty string)
+   * @throws {PeerNotFoundError} Peer does not exist (404 Not Found)
+   * @throws {UnauthorizedError} Admin API authentication failed (401)
+   * @throws {NetworkError} Connection to admin API failed
+   * @throws {ConnectorError} Admin API server error (5xx)
+   */
+  async removePeer(peerId) {
+    if (!peerId || typeof peerId !== "string" || peerId.trim() === "") {
+      throw new ValidationError("peerId must be a non-empty string");
+    }
+    const url = `${this.adminUrl}/admin/peers/${encodeURIComponent(peerId)}`;
+    await withRetry(async () => this.sendRemovePeerRequest(url, peerId), {
+      maxRetries: this.retryConfig.maxRetries,
+      retryDelay: this.retryConfig.retryDelay,
+      exponentialBackoff: true,
+      shouldRetry: (error) => {
+        return error instanceof NetworkError;
+      }
+    });
+  }
+  /**
+   * Add multiple peers in parallel for efficient bootstrapping.
+   *
+   * Uses Promise.allSettled() to execute peer additions concurrently,
+   * returning results for each operation regardless of individual failures.
+   *
+   * @param configs - Array of peer configurations to add
+   * @returns Array of results indicating success/failure for each peer
+   *
+   * @example
+   * ```typescript
+   * const results = await admin.addPeers([
+   *   { id: 'peer1', url: 'btp+ws://...', authToken: 'token1' },
+   *   { id: 'peer2', url: 'btp+ws://...', authToken: 'token2' },
+   * ]);
+   *
+   * results.forEach(result => {
+   *   if (result.success) {
+   *     console.log(`Added peer: ${result.peerId}`);
+   *   } else {
+   *     console.error(`Failed to add ${result.peerId}:`, result.error);
+   *   }
+   * });
+   * ```
+   */
+  async addPeers(configs) {
+    const results = await Promise.allSettled(
+      configs.map((config) => this.addPeer(config))
+    );
+    return results.map((result, index) => {
+      const config = configs[index];
+      return {
+        peerId: config ? config.id : "unknown",
+        success: result.status === "fulfilled",
+        error: result.status === "rejected" ? result.reason : void 0
+      };
+    });
+  }
+  /**
+   * Remove multiple peers in parallel.
+   *
+   * Uses Promise.allSettled() to execute peer removals concurrently,
+   * returning results for each operation regardless of individual failures.
+   *
+   * @param peerIds - Array of peer IDs to remove
+   * @returns Array of results indicating success/failure for each peer
+   *
+   * @example
+   * ```typescript
+   * const results = await admin.removePeers(['peer1', 'peer2', 'peer3']);
+   *
+   * const succeeded = results.filter(r => r.success).length;
+   * console.log(`Removed ${succeeded}/${results.length} peers`);
+   * ```
+   */
+  async removePeers(peerIds) {
+    const results = await Promise.allSettled(
+      peerIds.map((peerId) => this.removePeer(peerId))
+    );
+    return results.map((result, index) => {
+      const peerId = peerIds[index];
+      return {
+        peerId: peerId ?? "unknown",
+        success: result.status === "fulfilled",
+        error: result.status === "rejected" ? result.reason : void 0
+      };
+    });
+  }
+  /**
+   * Send HTTP POST request to add a peer.
+   * Separated for retry logic wrapping.
+   */
+  async sendAddPeerRequest(url, config) {
+    let connectorUrl = config.url;
+    if (connectorUrl.startsWith("btp+")) {
+      connectorUrl = connectorUrl.replace(/^btp\+/, "");
+    }
+    try {
+      const response = await this.httpClient(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          ...config,
+          url: connectorUrl
+        }),
+        signal: AbortSignal.timeout(this.timeout)
+      });
+      if (response.ok) {
+        return;
+      }
+      await this.handleErrorResponse(response, `POST ${url}`, config.id);
+    } catch (error) {
+      this.handleNetworkError(error, url, "addPeer");
+    }
+  }
+  /**
+   * Send HTTP DELETE request to remove a peer.
+   * Separated for retry logic wrapping.
+   */
+  async sendRemovePeerRequest(url, peerId) {
+    try {
+      const response = await this.httpClient(url, {
+        method: "DELETE",
+        signal: AbortSignal.timeout(this.timeout)
+      });
+      if (response.ok) {
+        return;
+      }
+      await this.handleErrorResponse(response, `DELETE ${url}`, peerId);
+    } catch (error) {
+      this.handleNetworkError(error, url, "removePeer");
+    }
+  }
+  /**
+   * Handle network errors from HTTP requests.
+   *
+   * Converts connection failures, timeouts, and unknown errors to NetworkError.
+   * Re-throws existing ToonClientError instances.
+   *
+   * @param error - Error thrown by HTTP client
+   * @param url - Request URL (for error messages)
+   * @param operation - Operation name (for error messages)
+   * @throws {NetworkError} Network connection or timeout error
+   */
+  handleNetworkError(error, url, operation) {
+    if (error instanceof Error && error.name === "AbortError") {
+      throw new NetworkError(
+        `Request to ${url} timed out after ${this.timeout}ms`,
+        error
+      );
+    }
+    if (error instanceof Error && (error.message.includes("ECONNREFUSED") || error.message.includes("ETIMEDOUT") || error.message.includes("ENOTFOUND"))) {
+      throw new NetworkError(
+        `Failed to connect to connector admin API at ${url}: ${error.message}`,
+        error
+      );
+    }
+    if (error instanceof ValidationError || error instanceof PeerAlreadyExistsError || error instanceof PeerNotFoundError || error instanceof UnauthorizedError || error instanceof ConnectorError) {
+      throw error;
+    }
+    throw new NetworkError(
+      `Unexpected error during ${operation}: ${error instanceof Error ? error.message : String(error)}`,
+      error instanceof Error ? error : void 0
+    );
+  }
+  /**
+   * Handle HTTP error responses from the admin API.
+   *
+   * Converts HTTP status codes to appropriate error types.
+   *
+   * @param response - HTTP response from admin API
+   * @param endpoint - Endpoint being called (for error messages)
+   * @param peerId - Peer ID (for error messages)
+   * @throws {UnauthorizedError} 401 Unauthorized
+   * @throws {PeerNotFoundError} 404 Not Found
+   * @throws {PeerAlreadyExistsError} 409 Conflict
+   * @throws {ConnectorError} 5xx Server Error
+   */
+  async handleErrorResponse(response, endpoint, peerId) {
+    const status = response.status;
+    const statusText = response.statusText;
+    let errorMessage = "";
+    try {
+      const body = await response.text();
+      if (body) {
+        errorMessage = ` - ${body}`;
+      }
+    } catch {
+    }
+    switch (status) {
+      case 401:
+        throw new UnauthorizedError(
+          `Admin API authentication failed for ${endpoint}: ${statusText}${errorMessage}`
+        );
+      case 404:
+        throw new PeerNotFoundError(
+          `Peer not found: "${peerId}" (${endpoint}): ${statusText}${errorMessage}`
+        );
+      case 409:
+        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}`
+        );
+    }
+  }
+};
+export {
+  BtpRuntimeClient,
+  ChannelManager,
+  ConnectorError,
+  EvmSigner,
+  HttpConnectorAdmin,
+  HttpRuntimeClient,
+  NetworkError,
+  OnChainChannelClient,
+  ToonClient,
+  ToonClientError,
+  ValidationError,
+  applyDefaults,
+  buildSettlementInfo,
+  validateConfig,
+  withRetry
+};
+//# sourceMappingURL=index.js.map